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

golf/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.10"
+__version__ = "0.1.12"

golf/auth/__init__.py

@@ -9,24 +9,32 @@ from typing import List, Optional, Tuple
 
 from mcp.server.auth.settings import AuthSettings, ClientRegistrationOptions
 
-from .provider import ProviderConfig
-from .oauth import GolfOAuthProvider, create_callback_handler
-from .helpers import get_access_token, get_provider_token, extract_token_from_header, get_api_key, set_api_key, debug_api_key_context
 from .api_key import configure_api_key, get_api_key_config, is_api_key_configured
+from .helpers import (
+    debug_api_key_context,
+    extract_token_from_header,
+    get_access_token,
+    get_api_key,
+    get_provider_token,
+    set_api_key,
+)
+from .oauth import GolfOAuthProvider, create_callback_handler
+from .provider import ProviderConfig
+
 
 class AuthConfig:
     """Configuration for OAuth authentication in GolfMCP."""
-    
+
     def __init__(
-        self, 
+        self,
         provider_config: ProviderConfig,
-        required_scopes: List[str],
+        required_scopes: list[str],
         callback_path: str = "/auth/callback",
         login_path: str = "/login",
-        error_path: str = "/auth-error"
-    ):
+        error_path: str = "/auth-error",
+    ) -> None:
         """Initialize authentication configuration.
-        
+
         Args:
             provider_config: Configuration for the OAuth provider
             required_scopes: Scopes required for all authenticated requests
@@ -39,34 +47,36 @@ class AuthConfig:
         self.callback_path = callback_path
         self.login_path = login_path
         self.error_path = error_path
-        
+
         # Create the OAuth provider
         self.provider = GolfOAuthProvider(provider_config)
-        
+
         # Create auth settings for FastMCP
         self.auth_settings = AuthSettings(
             issuer_url=provider_config.issuer_url or "http://localhost:3000",
             client_registration_options=ClientRegistrationOptions(
                 enabled=True,
                 valid_scopes=provider_config.scopes,
-                default_scopes=provider_config.scopes
+                default_scopes=provider_config.scopes,
             ),
-            required_scopes=required_scopes or provider_config.scopes
+            required_scopes=required_scopes or provider_config.scopes,
         )
 
+
 # Global state for the build process
-_auth_config: Optional[AuthConfig] = None
+_auth_config: AuthConfig | None = None
+
 
 def configure_auth(
     provider_config=None,
     provider=None,
-    required_scopes: Optional[List[str]] = None,
+    required_scopes: list[str] | None = None,
     callback_path: str = "/auth/callback",
 ) -> None:
     """Configure authentication for a GolfMCP server.
-    
+
     This function should be called in pre_build.py to set up authentication.
-    
+
     Args:
         provider_config: Configuration for the OAuth provider (new parameter name)
         provider: Configuration for the OAuth provider (old parameter name, deprecated)
@@ -75,22 +85,23 @@ def configure_auth(
         public_paths: List of paths that don't require authentication (deprecated, no longer used)
     """
     global _auth_config
-    
+
     # Handle backward compatibility with old parameter name
     if provider_config is None and provider is not None:
         provider_config = provider
     elif provider_config is None and provider is None:
         raise ValueError("Either provider_config or provider must be provided")
-    
+
     _auth_config = AuthConfig(
         provider_config=provider_config,
         required_scopes=required_scopes or provider_config.scopes,
-        callback_path=callback_path
+        callback_path=callback_path,
     )
 
-def get_auth_config() -> Tuple[Optional[ProviderConfig], List[str]]:
+
+def get_auth_config() -> tuple[ProviderConfig | None, list[str]]:
     """Get the current authentication configuration.
-    
+
     Returns:
         Tuple of (provider_config, required_scopes)
     """
@@ -98,13 +109,14 @@ def get_auth_config() -> Tuple[Optional[ProviderConfig], List[str]]:
         return _auth_config.provider_config, _auth_config.required_scopes
     return None, []
 
-def create_auth_provider() -> Optional[GolfOAuthProvider]:
+
+def create_auth_provider() -> GolfOAuthProvider | None:
     """Create an OAuth provider from the configured provider settings.
-    
+
     Returns:
         GolfOAuthProvider instance or None if not configured
     """
     if not _auth_config:
         return None
-        
-    return _auth_config.provider 
+
+    return _auth_config.provider

golf/auth/api_key.py

@@ -5,56 +5,51 @@ allowing tools to access API keys from request headers and forward them to
 upstream services.
 """
 
-from typing import Optional
 from pydantic import BaseModel, Field
 
 
 class ApiKeyConfig(BaseModel):
     """Configuration for API key authentication."""
-    
+
     header_name: str = Field(
-        "X-API-Key",
-        description="Name of the header containing the API key"
+        "X-API-Key", description="Name of the header containing the API key"
     )
     header_prefix: str = Field(
         "",
-        description="Optional prefix to strip from the header value (e.g., 'Bearer ')"
+        description="Optional prefix to strip from the header value (e.g., 'Bearer ')",
     )
     required: bool = Field(
-        True,
-        description="Whether API key is required for all requests"
+        True, description="Whether API key is required for all requests"
     )
 
 
 # Global configuration storage
-_api_key_config: Optional[ApiKeyConfig] = None
+_api_key_config: ApiKeyConfig | None = None
 
 
 def configure_api_key(
-    header_name: str = "X-API-Key",
-    header_prefix: str = "",
-    required: bool = True
+    header_name: str = "X-API-Key", header_prefix: str = "", required: bool = True
 ) -> None:
     """Configure API key extraction from request headers.
-    
+
     This function should be called in pre_build.py to set up API key handling.
-    
+
     Args:
         header_name: Name of the header containing the API key (default: "X-API-Key")
         header_prefix: Optional prefix to strip from the header value (e.g., "Bearer ")
         required: Whether API key is required for all requests (default: True)
-        
+
     Example:
         # In pre_build.py
         from golf.auth.api_key import configure_api_key
-        
+
         # Require API key for all requests
         configure_api_key(
             header_name="Authorization",
             header_prefix="Bearer ",
             required=True
         )
-        
+
         # Or make API key optional (pass-through mode)
         configure_api_key(
             header_name="Authorization",
@@ -64,15 +59,13 @@ def configure_api_key(
     """
     global _api_key_config
     _api_key_config = ApiKeyConfig(
-        header_name=header_name,
-        header_prefix=header_prefix,
-        required=required
+        header_name=header_name, header_prefix=header_prefix, required=required
     )
 
 
-def get_api_key_config() -> Optional[ApiKeyConfig]:
+def get_api_key_config() -> ApiKeyConfig | None:
     """Get the current API key configuration.
-    
+
     Returns:
         The API key configuration if set, None otherwise
     """
@@ -81,8 +74,8 @@ def get_api_key_config() -> Optional[ApiKeyConfig]:
 
 def is_api_key_configured() -> bool:
     """Check if API key authentication is configured.
-    
+
     Returns:
         True if API key authentication is configured, False otherwise
     """
-    return _api_key_config is not None 
+    return _api_key_config is not None

golf/auth/helpers.py

@@ -1,7 +1,7 @@
 """Helper functions for working with authentication in MCP context."""
 
-from typing import Optional, Dict, Any
 from contextvars import ContextVar
+from typing import Any
 
 # Re-export get_access_token from the MCP SDK
 from mcp.server.auth.middleware.auth_context import get_access_token
@@ -9,10 +9,11 @@ from mcp.server.auth.middleware.auth_context import get_access_token
 from .oauth import GolfOAuthProvider
 
 # Context variable to store the active OAuth provider
-_active_golf_oauth_provider: Optional[GolfOAuthProvider] = None
+_active_golf_oauth_provider: GolfOAuthProvider | None = None
 
 # Context variable to store the current request's API key
-_current_api_key: ContextVar[Optional[str]] = ContextVar('current_api_key', default=None)
+_current_api_key: ContextVar[str | None] = ContextVar("current_api_key", default=None)
+
 
 def _set_active_golf_oauth_provider(provider: GolfOAuthProvider) -> None:
     """
@@ -22,14 +23,15 @@ def _set_active_golf_oauth_provider(provider: GolfOAuthProvider) -> None:
     global _active_golf_oauth_provider
     _active_golf_oauth_provider = provider
 
-def get_provider_token() -> Optional[str]:
+
+def get_provider_token() -> str | None:
     """
     Get a provider token (e.g., GitHub token) associated with the current
     MCP session's access token.
 
     This relies on _set_active_golf_oauth_provider being called at server startup.
     """
-    mcp_access_token = get_access_token() # From MCP SDK, uses its own ContextVar
+    mcp_access_token = get_access_token()  # From MCP SDK, uses its own ContextVar
     if not mcp_access_token:
         # No active MCP session token.
         return None
@@ -37,14 +39,15 @@ def get_provider_token() -> Optional[str]:
     provider = _active_golf_oauth_provider
     if not provider:
         return None
-    
+
     if not hasattr(provider, "get_provider_token"):
         return None
 
     # Call the get_provider_token method on the actual GolfOAuthProvider instance
     return provider.get_provider_token(mcp_access_token.token)
 
-def extract_token_from_header(auth_header: str) -> Optional[str]:
+
+def extract_token_from_header(auth_header: str) -> str | None:
     """Extract bearer token from Authorization header.
 
     Args:
@@ -57,39 +60,41 @@ def extract_token_from_header(auth_header: str) -> Optional[str]:
         return None
 
     parts = auth_header.split()
-    if len(parts) != 2 or parts[0].lower() != 'bearer':
+    if len(parts) != 2 or parts[0].lower() != "bearer":
         return None
 
     return parts[1]
 
-def set_api_key(api_key: Optional[str]) -> None:
+
+def set_api_key(api_key: str | None) -> None:
     """Set the API key for the current request context.
-    
+
     This is an internal function used by the middleware.
-    
+
     Args:
         api_key: The API key to store in the context
     """
     _current_api_key.set(api_key)
 
-def get_api_key() -> Optional[str]:
+
+def get_api_key() -> str | None:
     """Get the API key from the current request context.
-    
+
     This function should be used in tools to retrieve the API key
     that was sent in the request headers.
-    
+
     Returns:
         The API key if available, None otherwise
-        
+
     Example:
         # In a tool file
         from golf.auth import get_api_key
-        
+
         async def call_api():
             api_key = get_api_key()
             if not api_key:
                 return {"error": "No API key provided"}
-            
+
             # Use the API key in your request
             headers = {"Authorization": f"Bearer {api_key}"}
             ...
@@ -98,79 +103,84 @@ def get_api_key() -> Optional[str]:
     try:
         # This follows the FastMCP pattern for accessing HTTP requests
         from fastmcp.server.dependencies import get_http_request
+
         request = get_http_request()
-        
-        if request and hasattr(request, 'state') and hasattr(request.state, 'api_key'):
+
+        if request and hasattr(request, "state") and hasattr(request.state, "api_key"):
             api_key = request.state.api_key
             return api_key
-        
+
         # Get the API key configuration
         from golf.auth.api_key import get_api_key_config
+
         api_key_config = get_api_key_config()
-        
+
         if api_key_config and request:
             # Extract API key from headers
             header_name = api_key_config.header_name
             header_prefix = api_key_config.header_prefix
-            
+
             # Case-insensitive header lookup
             api_key = None
             for k, v in request.headers.items():
                 if k.lower() == header_name.lower():
                     api_key = v
                     break
-            
+
             # Strip prefix if configured
             if api_key and header_prefix and api_key.startswith(header_prefix):
-                api_key = api_key[len(header_prefix):]
-            
+                api_key = api_key[len(header_prefix) :]
+
             if api_key:
                 return api_key
-    except (ImportError, RuntimeError) as e:
+    except (ImportError, RuntimeError):
         # FastMCP not available or not in HTTP context
         pass
-    except Exception as e:
+    except Exception:
         pass
-    
+
     # Final fallback: environment variable (for development/testing)
     import os
-    env_api_key = os.environ.get('API_KEY')
+
+    env_api_key = os.environ.get("API_KEY")
     if env_api_key:
         return env_api_key
-    
+
     return None
 
-def get_api_key_from_request(request) -> Optional[str]:
+
+def get_api_key_from_request(request) -> str | None:
     """Get the API key from a specific request object.
-    
+
     This is useful when you have direct access to the request object.
-    
+
     Args:
         request: The Starlette Request object
-        
+
     Returns:
         The API key if available, None otherwise
     """
     # Check request state first (set by our middleware)
-    if hasattr(request, 'state') and hasattr(request.state, 'api_key'):
+    if hasattr(request, "state") and hasattr(request.state, "api_key"):
         return request.state.api_key
-    
+
     # Fall back to context variable
     return _current_api_key.get()
 
-def debug_api_key_context() -> Dict[str, Any]:
+
+def debug_api_key_context() -> dict[str, Any]:
     """Debug function to inspect API key context.
-    
+
     Returns a dictionary with debugging information about the current
     API key context. Useful for troubleshooting authentication issues.
-    
+
     Returns:
         Dictionary with debug information
     """
     import asyncio
-    import sys
     import os
-    
+    import sys
+
     debug_info = {
         "context_var_value": _current_api_key.get(),
         "has_async_task": False,
@@ -179,11 +189,11 @@ def debug_api_key_context() -> Dict[str, Any]:
         "main_module_has_context": False,
         "request_id_from_context": None,
         "env_vars": {
-            "API_KEY": bool(os.environ.get('API_KEY')),
-            "GOLF_API_KEY_DEBUG": os.environ.get('GOLF_API_KEY_DEBUG', 'false')
-        }
+            "API_KEY": bool(os.environ.get("API_KEY")),
+            "GOLF_API_KEY_DEBUG": os.environ.get("GOLF_API_KEY_DEBUG", "false"),
+        },
     }
-    
+
     try:
         task = asyncio.current_task()
         if task:
@@ -191,17 +201,21 @@ def debug_api_key_context() -> Dict[str, Any]:
             debug_info["task_id"] = id(task)
     except:
         pass
-    
+
     try:
-        main_module = sys.modules.get('__main__')
+        main_module = sys.modules.get("__main__")
         if main_module:
-            debug_info["main_module_has_storage"] = hasattr(main_module, 'api_key_storage')
-            debug_info["main_module_has_context"] = hasattr(main_module, 'request_id_context')
-            
-            if hasattr(main_module, 'request_id_context'):
-                request_id_context = getattr(main_module, 'request_id_context')
+            debug_info["main_module_has_storage"] = hasattr(
+                main_module, "api_key_storage"
+            )
+            debug_info["main_module_has_context"] = hasattr(
+                main_module, "request_id_context"
+            )
+
+            if hasattr(main_module, "request_id_context"):
+                request_id_context = main_module.request_id_context
                 debug_info["request_id_from_context"] = request_id_context.get()
     except:
         pass
-    
-    return debug_info 
+
+    return debug_info