fastmcp 1.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

fastmcp/prompts/prompt_manager.py

@@ -1,9 +1,10 @@
 """Prompt management functionality."""
 
-from typing import Dict, Optional
+from collections.abc import Awaitable, Callable
+from typing import Any
 
-
-from fastmcp.prompts.base import Prompt
+from fastmcp.prompts.prompt import Message, Prompt, PromptResult
+from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
 
 logger = get_logger(__name__)
@@ -12,25 +13,78 @@ logger = get_logger(__name__)
 class PromptManager:
     """Manages FastMCP prompts."""
 
-    def __init__(self, warn_on_duplicate_prompts: bool = True):
-        self._prompts: Dict[str, Prompt] = {}
-        self.warn_on_duplicate_prompts = warn_on_duplicate_prompts
+    def __init__(self, duplicate_behavior: DuplicateBehavior = DuplicateBehavior.WARN):
+        self._prompts: dict[str, Prompt] = {}
+        self.duplicate_behavior = duplicate_behavior
+
+    def get_prompt(self, name: str) -> Prompt | None:
+        """Get prompt by name."""
+        return self._prompts.get(name)
+
+    def list_prompts(self) -> list[Prompt]:
+        """List all registered prompts."""
+        return list(self._prompts.values())
+
+    def add_prompt_from_fn(
+        self,
+        fn: Callable[..., PromptResult | Awaitable[PromptResult]],
+        name: str | None = None,
+        description: str | None = None,
+        tags: set[str] | None = None,
+    ) -> Prompt:
+        """Create a prompt from a function."""
+        prompt = Prompt.from_function(fn, name=name, description=description, tags=tags)
+        return self.add_prompt(prompt)
 
     def add_prompt(self, prompt: Prompt) -> Prompt:
         """Add a prompt to the manager."""
-        logger.debug(f"Adding prompt: {prompt.name}")
+
+        # Check for duplicates
         existing = self._prompts.get(prompt.name)
         if existing:
-            if self.warn_on_duplicate_prompts:
+            if self.duplicate_behavior == DuplicateBehavior.WARN:
                 logger.warning(f"Prompt already exists: {prompt.name}")
-            return existing
+                self._prompts[prompt.name] = prompt
+            elif self.duplicate_behavior == DuplicateBehavior.REPLACE:
+                self._prompts[prompt.name] = prompt
+            elif self.duplicate_behavior == DuplicateBehavior.ERROR:
+                raise ValueError(f"Prompt already exists: {prompt.name}")
+            elif self.duplicate_behavior == DuplicateBehavior.IGNORE:
+                pass
+
         self._prompts[prompt.name] = prompt
         return prompt
 
-    def get_prompt(self, name: str) -> Optional[Prompt]:
-        """Get prompt by name."""
-        return self._prompts.get(name)
+    async def render_prompt(
+        self, name: str, arguments: dict[str, Any] | None = None
+    ) -> list[Message]:
+        """Render a prompt by name with arguments."""
+        prompt = self.get_prompt(name)
+        if not prompt:
+            raise ValueError(f"Unknown prompt: {name}")
 
-    def list_prompts(self) -> list[Prompt]:
-        """List all registered prompts."""
-        return list(self._prompts.values())
+        return await prompt.render(arguments)
+
+    def import_prompts(
+        self, manager: "PromptManager", prefix: str | None = None
+    ) -> None:
+        """
+        Import all prompts from another PromptManager with prefixed names.
+
+        Args:
+            manager: Another PromptManager instance to import prompts from
+            prefix: Prefix to add to prompt names. The resulting prompt name will
+                   be in the format "{prefix}{original_name}" if prefix is provided,
+                   otherwise the original name is used.
+                   For example, with prefix "weather/" and prompt "forecast_prompt",
+                   the imported prompt would be available as "weather/forecast_prompt"
+        """
+        for name, prompt in manager._prompts.items():
+            # Create prefixed name
+            prefixed_name = f"{prefix}{name}" if prefix else name
+
+            new_prompt = prompt.copy(updates=dict(name=prefixed_name))
+
+            # Store the prompt with the prefixed name
+            self.add_prompt(new_prompt)
+            logger.debug(f'Imported prompt "{name}" as "{prefixed_name}"')

fastmcp/resources/__init__.py

@@ -1,14 +1,14 @@
-from .base import Resource
+from .resource import Resource
+from .resource_manager import ResourceManager
+from .template import ResourceTemplate
 from .types import (
-    TextResource,
     BinaryResource,
-    FunctionResource,
+    DirectoryResource,
     FileResource,
+    FunctionResource,
     HttpResource,
-    DirectoryResource,
+    TextResource,
 )
-from .templates import ResourceTemplate
-from .resource_manager import ResourceManager
 
 __all__ = [
     "Resource",

fastmcp/resources/{base.py → resource.py}

@@ -1,17 +1,21 @@
 """Base classes and interfaces for FastMCP resources."""
 
 import abc
-from typing import Union, Annotated
+from typing import Annotated, Any
 
 from pydantic import (
     AnyUrl,
     BaseModel,
+    BeforeValidator,
     ConfigDict,
     Field,
     UrlConstraints,
     ValidationInfo,
     field_validator,
 )
+from typing_extensions import Self
+
+from fastmcp.utilities.types import _convert_set_defaults
 
 
 class Resource(BaseModel, abc.ABC):
@@ -26,6 +30,9 @@ class Resource(BaseModel, abc.ABC):
     description: str | None = Field(
         description="Description of the resource", default=None
     )
+    tags: Annotated[set[str], BeforeValidator(_convert_set_defaults)] = Field(
+        default_factory=set, description="Tags for the resource"
+    )
     mime_type: str = Field(
         default="text/plain",
         description="MIME type of the resource content",
@@ -43,6 +50,18 @@ class Resource(BaseModel, abc.ABC):
         raise ValueError("Either name or uri must be provided")
 
     @abc.abstractmethod
-    async def read(self) -> Union[str, bytes]:
+    async def read(self) -> str | bytes:
         """Read the resource content."""
         pass
+
+    def copy(self, updates: dict[str, Any] | None = None) -> Self:
+        """Copy the resource with optional updates."""
+        data = self.model_dump()
+        if updates:
+            data.update(updates)
+        return type(self)(**data)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Resource):
+            return False
+        return self.model_dump() == other.model_dump()

fastmcp/resources/resource_manager.py

@@ -1,11 +1,13 @@
 """Resource manager functionality."""
 
-from typing import Callable, Dict, Optional, Union
+from collections.abc import Callable
+from typing import Any
 
 from pydantic import AnyUrl
 
-from fastmcp.resources.base import Resource
-from fastmcp.resources.templates import ResourceTemplate
+from fastmcp.resources.resource import Resource
+from fastmcp.resources.template import ResourceTemplate
+from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
 
 logger = get_logger(__name__)
@@ -14,10 +16,10 @@ logger = get_logger(__name__)
 class ResourceManager:
     """Manages FastMCP resources."""
 
-    def __init__(self, warn_on_duplicate_resources: bool = True):
-        self._resources: Dict[str, Resource] = {}
-        self._templates: Dict[str, ResourceTemplate] = {}
-        self.warn_on_duplicate_resources = warn_on_duplicate_resources
+    def __init__(self, duplicate_behavior: DuplicateBehavior = DuplicateBehavior.WARN):
+        self._resources: dict[str, Resource] = {}
+        self._templates: dict[str, ResourceTemplate] = {}
+        self.duplicate_behavior = duplicate_behavior
 
     def add_resource(self, resource: Resource) -> Resource:
         """Add a resource to the manager.
@@ -34,37 +36,76 @@ class ResourceManager:
             extra={
                 "uri": resource.uri,
                 "type": type(resource).__name__,
-                "name": resource.name,
+                "resource_name": resource.name,
             },
         )
         existing = self._resources.get(str(resource.uri))
         if existing:
-            if self.warn_on_duplicate_resources:
+            if self.duplicate_behavior == DuplicateBehavior.WARN:
                 logger.warning(f"Resource already exists: {resource.uri}")
-            return existing
+                self._resources[str(resource.uri)] = resource
+            elif self.duplicate_behavior == DuplicateBehavior.REPLACE:
+                self._resources[str(resource.uri)] = resource
+            elif self.duplicate_behavior == DuplicateBehavior.ERROR:
+                raise ValueError(f"Resource already exists: {resource.uri}")
+            elif self.duplicate_behavior == DuplicateBehavior.IGNORE:
+                pass
         self._resources[str(resource.uri)] = resource
         return resource
 
-    def add_template(
+    def add_template_from_fn(
         self,
-        fn: Callable,
+        fn: Callable[..., Any],
         uri_template: str,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        mime_type: Optional[str] = None,
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
     ) -> ResourceTemplate:
-        """Add a template from a function."""
+        """Create a template from a function."""
         template = ResourceTemplate.from_function(
             fn,
             uri_template=uri_template,
             name=name,
             description=description,
             mime_type=mime_type,
+            tags=tags,
         )
+        return self.add_template(template)
+
+    def add_template(self, template: ResourceTemplate) -> ResourceTemplate:
+        """Add a template to the manager.
+
+        Args:
+            template: A ResourceTemplate instance to add
+
+        Returns:
+            The added template. If a template with the same URI already exists,
+            returns the existing template.
+        """
+        logger.debug(
+            "Adding resource",
+            extra={
+                "uri": template.uri_template,
+                "type": type(template).__name__,
+                "resource_name": template.name,
+            },
+        )
+        existing = self._templates.get(str(template.uri_template))
+        if existing:
+            if self.duplicate_behavior == DuplicateBehavior.WARN:
+                logger.warning(f"Resource already exists: {template.uri_template}")
+                self._templates[str(template.uri_template)] = template
+            elif self.duplicate_behavior == DuplicateBehavior.REPLACE:
+                self._templates[str(template.uri_template)] = template
+            elif self.duplicate_behavior == DuplicateBehavior.ERROR:
+                raise ValueError(f"Resource already exists: {template.uri_template}")
+            elif self.duplicate_behavior == DuplicateBehavior.IGNORE:
+                pass
         self._templates[template.uri_template] = template
         return template
 
-    async def get_resource(self, uri: Union[AnyUrl, str]) -> Optional[Resource]:
+    async def get_resource(self, uri: AnyUrl | str) -> Resource | None:
         """Get resource by URI, checking concrete resources first, then templates."""
         uri_str = str(uri)
         logger.debug("Getting resource", extra={"uri": uri_str})
@@ -92,3 +133,61 @@ class ResourceManager:
         """List all registered templates."""
         logger.debug("Listing templates", extra={"count": len(self._templates)})
         return list(self._templates.values())
+
+    def import_resources(
+        self, manager: "ResourceManager", prefix: str | None = None
+    ) -> None:
+        """Import resources from another resource manager.
+
+        Resources are imported with a prefixed URI if a prefix is provided. For example,
+        if a resource has URI "data://users" and you import it with prefix "app+", the
+        imported resource will have URI "app+data://users". If no prefix is provided,
+        the original URI is used.
+
+        Args:
+            manager: The ResourceManager to import from
+            prefix: A prefix to apply to the resource URIs, including the delimiter.
+                   For example, "app+" would result in URIs like "app+data://users".
+                   If None, the original URI is used.
+        """
+        for uri, resource in manager._resources.items():
+            # Create prefixed URI and copy the resource with the new URI
+            prefixed_uri = f"{prefix}{uri}" if prefix else uri
+
+            new_resource = resource.copy(updates=dict(uri=prefixed_uri))
+
+            # Store directly in resources dictionary
+            self.add_resource(new_resource)
+            logger.debug(f'Imported resource "{uri}" as "{prefixed_uri}"')
+
+    def import_templates(
+        self, manager: "ResourceManager", prefix: str | None = None
+    ) -> None:
+        """Import resource templates from another resource manager.
+
+        Templates are imported with a prefixed URI template if a prefix is provided.
+        For example, if a template has URI template "data://users/{id}" and you import
+        it with prefix "app+", the imported template will have URI template
+        "app+data://users/{id}". If no prefix is provided, the original URI template is used.
+
+        Args:
+            manager: The ResourceManager to import templates from
+            prefix: A prefix to apply to the template URIs, including the delimiter.
+                   For example, "app+" would result in URI templates like "app+data://users/{id}".
+                   If None, the original URI template is used.
+        """
+        for uri_template, template in manager._templates.items():
+            # Create prefixed URI template and copy the template with the new URI template
+            prefixed_uri_template = (
+                f"{prefix}{uri_template}" if prefix else uri_template
+            )
+
+            new_template = template.copy(
+                updates=dict(uri_template=prefixed_uri_template)
+            )
+
+            # Store directly in templates dictionary
+            self.add_template(new_template)
+            logger.debug(
+                f'Imported template "{uri_template}" as "{prefixed_uri_template}"'
+            )

fastmcp/resources/{templates.py → template.py}

@@ -1,12 +1,17 @@
 """Resource template functionality."""
 
+from __future__ import annotations
+
 import inspect
 import re
-from typing import Any, Callable, Dict, Optional
+from collections.abc import Callable
+from typing import Annotated, Any
 
-from pydantic import BaseModel, Field, TypeAdapter, validate_call
+from pydantic import BaseModel, BeforeValidator, Field, TypeAdapter, validate_call
+from typing_extensions import Self
 
 from fastmcp.resources.types import FunctionResource, Resource
+from fastmcp.utilities.types import _convert_set_defaults
 
 
 class ResourceTemplate(BaseModel):
@@ -17,21 +22,27 @@ class ResourceTemplate(BaseModel):
     )
     name: str = Field(description="Name of the resource")
     description: str | None = Field(description="Description of what the resource does")
+    tags: Annotated[set[str], BeforeValidator(_convert_set_defaults)] = Field(
+        default_factory=set, description="Tags for the resource"
+    )
     mime_type: str = Field(
         default="text/plain", description="MIME type of the resource content"
     )
-    fn: Callable = Field(exclude=True)
-    parameters: dict = Field(description="JSON schema for function parameters")
+    fn: Callable[..., Any]
+    parameters: dict[str, Any] = Field(
+        description="JSON schema for function parameters"
+    )
 
     @classmethod
     def from_function(
         cls,
-        fn: Callable,
+        fn: Callable[..., Any],
         uri_template: str,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        mime_type: Optional[str] = None,
-    ) -> "ResourceTemplate":
+        name: str | None = None,
+        description: str | None = None,
+        mime_type: str | None = None,
+        tags: set[str] | None = None,
+    ) -> ResourceTemplate:
         """Create a template from a function."""
         func_name = name or fn.__name__
         if func_name == "<lambda>":
@@ -50,9 +61,10 @@ class ResourceTemplate(BaseModel):
             mime_type=mime_type or "text/plain",
             fn=fn,
             parameters=parameters,
+            tags=tags or set(),
         )
 
-    def matches(self, uri: str) -> Optional[Dict[str, Any]]:
+    def matches(self, uri: str) -> dict[str, Any] | None:
         """Check if URI matches template and extract parameters."""
         # Convert template to regex pattern
         pattern = self.uri_template.replace("{", "(?P<").replace("}", ">[^/]+)")
@@ -61,7 +73,7 @@ class ResourceTemplate(BaseModel):
             return match.groupdict()
         return None
 
-    async def create_resource(self, uri: str, params: Dict[str, Any]) -> Resource:
+    async def create_resource(self, uri: str, params: dict[str, Any]) -> Resource:
         """Create a resource from the template with the given parameters."""
         try:
             # Call function and check if result is a coroutine
@@ -75,6 +87,19 @@ class ResourceTemplate(BaseModel):
                 description=self.description,
                 mime_type=self.mime_type,
                 fn=lambda: result,  # Capture result in closure
+                tags=self.tags,
             )
         except Exception as e:
             raise ValueError(f"Error creating resource from template: {e}")
+
+    def copy(self, updates: dict[str, Any] | None = None) -> Self:
+        """Copy the resource template with optional updates."""
+        data = self.model_dump()
+        if updates:
+            data.update(updates)
+        return type(self)(**data)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ResourceTemplate):
+            return False
+        return self.model_dump() == other.model_dump()

fastmcp/resources/types.py

@@ -1,16 +1,19 @@
 """Concrete resource implementations."""
 
-import asyncio
+import inspect
 import json
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable, Union
+from typing import Any
 
+import anyio
+import anyio.to_thread
 import httpx
 import pydantic.json
 import pydantic_core
 from pydantic import Field, ValidationInfo
 
-from fastmcp.resources.base import Resource
+from fastmcp.resources.resource import Resource
 
 
 class TextResource(Resource):
@@ -46,12 +49,14 @@ class FunctionResource(Resource):
     - other types will be converted to JSON
     """
 
-    fn: Callable[[], Any] = Field(exclude=True)
+    fn: Callable[[], Any]
 
-    async def read(self) -> Union[str, bytes]:
+    async def read(self) -> str | bytes:
         """Read the resource by calling the wrapped function."""
         try:
-            result = self.fn()
+            result = (
+                await self.fn() if inspect.iscoroutinefunction(self.fn) else self.fn()
+            )
             if isinstance(result, Resource):
                 return await result.read()
             if isinstance(result, bytes):
@@ -100,12 +105,12 @@ class FileResource(Resource):
         mime_type = info.data.get("mime_type", "text/plain")
         return not mime_type.startswith("text/")
 
-    async def read(self) -> Union[str, bytes]:
+    async def read(self) -> str | bytes:
         """Read the file content."""
         try:
             if self.is_binary:
-                return await asyncio.to_thread(self.path.read_bytes)
-            return await asyncio.to_thread(self.path.read_text)
+                return await anyio.to_thread.run_sync(self.path.read_bytes)
+            return await anyio.to_thread.run_sync(self.path.read_text)
         except Exception as e:
             raise ValueError(f"Error reading file {self.path}: {e}")
 
@@ -114,11 +119,11 @@ class HttpResource(Resource):
     """A resource that reads from an HTTP endpoint."""
 
     url: str = Field(description="URL to fetch content from")
-    mime_type: str | None = Field(
+    mime_type: str = Field(
         default="application/json", description="MIME type of the resource content"
     )
 
-    async def read(self) -> Union[str, bytes]:
+    async def read(self) -> str | bytes:
         """Read the HTTP content."""
         async with httpx.AsyncClient() as client:
             response = await client.get(self.url)
@@ -136,7 +141,7 @@ class DirectoryResource(Resource):
     pattern: str | None = Field(
         default=None, description="Optional glob pattern to filter files"
     )
-    mime_type: str | None = Field(
+    mime_type: str = Field(
         default="application/json", description="MIME type of the resource content"
     )
 
@@ -173,7 +178,7 @@ class DirectoryResource(Resource):
     async def read(self) -> str:  # Always returns JSON string
         """Read the directory listing."""
         try:
-            files = await asyncio.to_thread(self.list_files)
+            files = await anyio.to_thread.run_sync(self.list_files)
             file_list = [str(f.relative_to(self.path)) for f in files if f.is_file()]
             return json.dumps({"files": file_list}, indent=2)
         except Exception as e:

fastmcp/server/__init__.py

@@ -0,0 +1,5 @@
+from .server import FastMCP
+from .context import Context
+
+
+__all__ = ["FastMCP", "Context"]