fastmcp 2.12.2__py3-none-any.whl → 2.12.4__py3-none-any.whl

fastmcp/utilities/logging.py

@@ -1,11 +1,14 @@
 """Logging utilities for FastMCP."""
 
+import contextlib
 import logging
-from typing import Any, Literal
+from typing import Any, Literal, cast
 
 from rich.console import Console
 from rich.logging import RichHandler
 
+import fastmcp
+
 
 def get_logger(name: str) -> logging.Logger:
     """Get a logger nested under FastMCP namespace.
@@ -16,13 +19,13 @@ def get_logger(name: str) -> logging.Logger:
     Returns:
         a configured logger instance
     """
-    return logging.getLogger(f"FastMCP.{name}")
+    return logging.getLogger(f"fastmcp.{name}")
 
 
 def configure_logging(
     level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | int = "INFO",
     logger: logging.Logger | None = None,
-    enable_rich_tracebacks: bool = True,
+    enable_rich_tracebacks: bool | None = None,
     **rich_kwargs: Any,
 ) -> None:
     """
@@ -33,9 +36,16 @@ def configure_logging(
         level: the log level to use
         rich_kwargs: the parameters to use for creating RichHandler
     """
+    # Check if logging is disabled in settings
+    if not fastmcp.settings.log_enabled:
+        return
+
+    # Use settings default if not specified
+    if enable_rich_tracebacks is None:
+        enable_rich_tracebacks = fastmcp.settings.enable_rich_tracebacks
 
     if logger is None:
-        logger = logging.getLogger("FastMCP")
+        logger = logging.getLogger("fastmcp")
 
     # Only configure the FastMCP logger namespace
     handler = RichHandler(
@@ -56,3 +66,55 @@ def configure_logging(
 
     # Don't propagate to the root logger
     logger.propagate = False
+
+
+@contextlib.contextmanager
+def temporary_log_level(
+    level: str | None,
+    logger: logging.Logger | None = None,
+    enable_rich_tracebacks: bool | None = None,
+    **rich_kwargs: Any,
+):
+    """Context manager to temporarily set log level and restore it afterwards.
+
+    Args:
+        level: The temporary log level to set (e.g., "DEBUG", "INFO")
+        logger: Optional logger to configure (defaults to FastMCP logger)
+        enable_rich_tracebacks: Whether to enable rich tracebacks
+        **rich_kwargs: Additional parameters for RichHandler
+
+    Usage:
+        with temporary_log_level("DEBUG"):
+            # Code that runs with DEBUG logging
+            pass
+        # Original log level is restored here
+    """
+    if level:
+        # Get the original log level from settings
+        original_level = fastmcp.settings.log_level
+
+        # Configure with new level
+        # Cast to proper type for type checker
+        log_level_literal = cast(
+            Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+            level.upper(),
+        )
+        configure_logging(
+            level=log_level_literal,
+            logger=logger,
+            enable_rich_tracebacks=enable_rich_tracebacks,
+            **rich_kwargs,
+        )
+        try:
+            yield
+        finally:
+            # Restore original configuration using configure_logging
+            # This will respect the log_enabled setting
+            configure_logging(
+                level=original_level,
+                logger=logger,
+                enable_rich_tracebacks=enable_rich_tracebacks,
+                **rich_kwargs,
+            )
+    else:
+        yield

fastmcp/utilities/mcp_server_config/v1/environments/uv.py

@@ -1,7 +1,5 @@
-import os
 import shutil
 import subprocess
-import sys
 from pathlib import Path
 from typing import Literal
 
@@ -59,7 +57,7 @@ class UVEnvironment(Environment):
             If no environment configuration is set, returns the command unchanged.
         """
         # If no environment setup is needed, return command as-is
-        if not self._needs_setup():
+        if not self._must_run_with_uv():
             return command
 
         args = ["uv", "run"]
@@ -75,7 +73,7 @@ class UVEnvironment(Environment):
         # Always add dependencies, requirements, and editable packages
         # These work with --project to add additional packages on top of the project env
         if self.dependencies:
-            for dep in self.dependencies:
+            for dep in sorted(set(self.dependencies)):
                 args.extend(["--with", dep])
 
         # Add requirements file
@@ -92,31 +90,7 @@ class UVEnvironment(Environment):
 
         return args
 
-    def run_with_uv(self, command: list[str]) -> None:
-        """Execute a command using uv run with this environment configuration.
-
-        Args:
-            command: Command and arguments to execute (e.g., ["fastmcp", "run", "server.py"])
-        """
-        import subprocess
-
-        # Build the full uv command
-        cmd = self.build_command(command)
-
-        # Set marker to prevent infinite loops when subprocess calls FastMCP again
-        env = os.environ | {"FASTMCP_UV_SPAWNED": "1"}
-
-        logger.debug(f"Running command: {' '.join(cmd)}")
-
-        try:
-            # Run without capturing output so it flows through naturally
-            process = subprocess.run(cmd, check=True, env=env)
-            sys.exit(process.returncode)
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Command failed: {e}")
-            sys.exit(e.returncode)
-
-    def _needs_setup(self) -> bool:
+    def _must_run_with_uv(self) -> bool:
         """Check if this environment config requires uv to set up.
 
         Returns:
@@ -132,15 +106,6 @@ class UVEnvironment(Environment):
             ]
         )
 
-    # Backward compatibility aliases
-    def needs_uv(self) -> bool:
-        """Deprecated: Use _needs_setup() internally or check if build_command modifies the command."""
-        return self._needs_setup()
-
-    def build_uv_run_command(self, command: list[str]) -> list[str]:
-        """Deprecated: Use build_command() instead."""
-        return self.build_command(command)
-
     async def prepare(self, output_dir: Path | None = None) -> None:
         """Prepare the Python environment using uv.
 
@@ -157,7 +122,7 @@ class UVEnvironment(Environment):
             )
 
         # Only prepare environment if there are actual settings to apply
-        if not self._needs_setup():
+        if not self._must_run_with_uv():
             logger.debug("No environment settings configured, skipping preparation")
             return
 

fastmcp/utilities/mcp_server_config/v1/mcp_server_config.py

@@ -26,7 +26,7 @@ logger = get_logger("cli.config")
 FASTMCP_JSON_SCHEMA = "https://gofastmcp.com/public/schemas/fastmcp.json/v1.json"
 
 
-# Type alias for source union (will expand with GitSource, etc in future)
+# Type alias for source union (will expand with GitSource, etc. in future)
 SourceType: TypeAlias = FileSystemSource
 
 # Type alias for environment union (will expand with other environments in future)
@@ -403,7 +403,8 @@ class MCPServerConfig(BaseModel):
                 run_args["port"] = self.deployment.port
             if self.deployment.path:
                 run_args["path"] = self.deployment.path
-            # Note: log_level not currently supported by run_async
+            if self.deployment.log_level:
+                run_args["log_level"] = self.deployment.log_level
 
         # Override with any provided kwargs
         run_args.update(kwargs)

fastmcp/utilities/mcp_server_config/v1/schema.json

@@ -9,7 +9,8 @@
               "enum": [
                 "stdio",
                 "http",
-                "sse"
+                "sse",
+                "streamable-http"
               ],
               "type": "string"
             },

fastmcp/utilities/storage.py

@@ -0,0 +1,204 @@
+"""Key-value storage utilities for persistent data management."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Protocol
+
+import pydantic_core
+
+from fastmcp.utilities.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class KVStorage(Protocol):
+    """Protocol for key-value storage of JSON data."""
+
+    async def get(self, key: str) -> dict[str, Any] | None:
+        """Get a JSON dict by key."""
+        ...
+
+    async def set(self, key: str, value: dict[str, Any]) -> None:
+        """Store a JSON dict by key."""
+        ...
+
+    async def delete(self, key: str) -> None:
+        """Delete a value by key."""
+        ...
+
+
+class JSONFileStorage:
+    """File-based key-value storage for JSON data with automatic metadata tracking.
+
+    Each key-value pair is stored as a separate JSON file on disk.
+    Keys are sanitized to be filesystem-safe.
+
+    The storage automatically wraps all data with metadata:
+    - timestamp: Timestamp when the entry was last written
+
+    Args:
+        cache_dir: Directory for storing JSON files
+    """
+
+    def __init__(self, cache_dir: Path):
+        """Initialize JSON file storage."""
+        self.cache_dir = cache_dir
+        self.cache_dir.mkdir(exist_ok=True, parents=True)
+
+    def _get_safe_key(self, key: str) -> str:
+        """Convert key to filesystem-safe string."""
+        safe_key = key
+
+        # Replace problematic characters with underscores
+        for char in [".", "/", "\\", ":", "*", "?", '"', "<", ">", "|", " "]:
+            safe_key = safe_key.replace(char, "_")
+
+        # Compress multiple underscores into one
+        while "__" in safe_key:
+            safe_key = safe_key.replace("__", "_")
+
+        # Strip leading and trailing underscores
+        safe_key = safe_key.strip("_")
+
+        return safe_key
+
+    def _get_file_path(self, key: str) -> Path:
+        """Get the file path for a given key."""
+        safe_key = self._get_safe_key(key)
+        return self.cache_dir / f"{safe_key}.json"
+
+    async def get(self, key: str) -> dict[str, Any] | None:
+        """Get a JSON dict from storage by key.
+
+        Args:
+            key: The key to retrieve
+
+        Returns:
+            The stored dict or None if not found
+        """
+        path = self._get_file_path(key)
+        try:
+            wrapper = json.loads(path.read_text())
+
+            # Expect wrapped format with metadata
+            if not isinstance(wrapper, dict) or "data" not in wrapper:
+                logger.warning(f"Invalid storage format for key '{key}'")
+                return None
+
+            logger.debug(f"Loaded data for key '{key}'")
+            return wrapper["data"]
+
+        except FileNotFoundError:
+            logger.debug(f"No data found for key '{key}'")
+            return None
+        except json.JSONDecodeError as e:
+            logger.warning(f"Failed to load data for key '{key}': {e}")
+            return None
+
+    async def set(self, key: str, value: dict[str, Any]) -> None:
+        """Store a JSON dict with metadata.
+
+        Args:
+            key: The key to store under
+            value: The dict to store
+        """
+        import time
+
+        path = self._get_file_path(key)
+        current_time = time.time()
+
+        # Create wrapper with metadata
+        wrapper = {
+            "data": value,
+            "timestamp": current_time,
+        }
+
+        # Use pydantic_core for consistent JSON serialization
+        json_data = pydantic_core.to_json(wrapper, fallback=str)
+        path.write_bytes(json_data)
+        logger.debug(f"Saved data for key '{key}'")
+
+    async def delete(self, key: str) -> None:
+        """Delete a value from storage.
+
+        Args:
+            key: The key to delete
+        """
+        path = self._get_file_path(key)
+        if path.exists():
+            path.unlink()
+            logger.debug(f"Deleted data for key '{key}'")
+
+    async def cleanup_old_entries(
+        self,
+        max_age_seconds: int = 30 * 24 * 60 * 60,  # 30 days default
+    ) -> int:
+        """Remove entries older than the specified age.
+
+        Uses the timestamp field to determine age.
+
+        Args:
+            max_age_seconds: Maximum age in seconds (default 30 days)
+
+        Returns:
+            Number of entries removed
+        """
+        import time
+
+        current_time = time.time()
+        removed_count = 0
+
+        for json_file in self.cache_dir.glob("*.json"):
+            try:
+                # Read the file and check timestamp
+                wrapper = json.loads(json_file.read_text())
+
+                # Check wrapped format
+                if not isinstance(wrapper, dict) or "data" not in wrapper:
+                    continue  # Invalid format, skip
+
+                if "timestamp" not in wrapper:
+                    continue  # No timestamp field, skip
+
+                entry_age = current_time - wrapper["timestamp"]
+                if entry_age > max_age_seconds:
+                    json_file.unlink()
+                    removed_count += 1
+                    logger.debug(
+                        f"Removed old entry '{json_file.stem}' (age: {entry_age:.0f}s)"
+                    )
+
+            except (json.JSONDecodeError, KeyError) as e:
+                logger.debug(f"Error reading {json_file.name}: {e}")
+                continue
+
+        if removed_count > 0:
+            logger.info(f"Cleaned up {removed_count} old entries from storage")
+
+        return removed_count
+
+
+class InMemoryStorage:
+    """In-memory key-value storage for JSON data.
+
+    Simple dict-based storage that doesn't persist across restarts.
+    Useful for testing or environments where file storage isn't available.
+    """
+
+    def __init__(self):
+        """Initialize in-memory storage."""
+        self._data: dict[str, dict[str, Any]] = {}
+
+    async def get(self, key: str) -> dict[str, Any] | None:
+        """Get a JSON dict from memory by key."""
+        return self._data.get(key)
+
+    async def set(self, key: str, value: dict[str, Any]) -> None:
+        """Store a JSON dict in memory."""
+        self._data[key] = value
+
+    async def delete(self, key: str) -> None:
+        """Delete a value from memory."""
+        self._data.pop(key, None)

fastmcp/utilities/tests.py

@@ -109,7 +109,7 @@ def run_server_in_process(
     proc.start()
 
     # Wait for server to be running
-    max_attempts = 10
+    max_attempts = 30
     attempt = 0
     while attempt < max_attempts and proc.is_alive():
         try:
@@ -117,10 +117,12 @@ def run_server_in_process(
                 s.connect((host, port))
                 break
         except ConnectionRefusedError:
-            if attempt < 3:
-                time.sleep(0.01)
-            else:
+            if attempt < 5:
+                time.sleep(0.05)
+            elif attempt < 15:
                 time.sleep(0.1)
+            else:
+                time.sleep(0.2)
             attempt += 1
     else:
         raise RuntimeError(f"Server failed to start after {max_attempts} attempts")
@@ -141,10 +143,10 @@ def run_server_in_process(
 def caplog_for_fastmcp(caplog):
     """Context manager to capture logs from FastMCP loggers even when propagation is disabled."""
     caplog.clear()
-    logger = logging.getLogger("FastMCP")
+    logger = logging.getLogger("fastmcp")
     logger.addHandler(caplog.handler)
     try:
-        yield
+        yield caplog
     finally:
         logger.removeHandler(caplog.handler)
 

fastmcp/utilities/types.py

@@ -31,6 +31,10 @@ NotSet = ...
 NotSetT: TypeAlias = EllipsisType
 
 
+def get_fn_name(fn: Callable[..., Any]) -> str:
+    return fn.__name__  # ty: ignore[unresolved-attribute]
+
+
 class FastMCPBaseModel(BaseModel):
     """Base model for FastMCP models."""
 
@@ -80,11 +84,11 @@ def get_cached_typeadapter(cls: T) -> TypeAdapter[T]:
                 # Handle both functions and methods
                 if inspect.ismethod(cls):
                     actual_func = cls.__func__
-                    code = actual_func.__code__
-                    globals_dict = actual_func.__globals__
-                    name = actual_func.__name__
-                    defaults = actual_func.__defaults__
-                    closure = actual_func.__closure__
+                    code = actual_func.__code__  # ty: ignore[unresolved-attribute]
+                    globals_dict = actual_func.__globals__  # ty: ignore[unresolved-attribute]
+                    name = actual_func.__name__  # ty: ignore[unresolved-attribute]
+                    defaults = actual_func.__defaults__  # ty: ignore[unresolved-attribute]
+                    closure = actual_func.__closure__  # ty: ignore[unresolved-attribute]
                 else:
                     code = cls.__code__
                     globals_dict = cls.__globals__