fastmcp 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

fastmcp/resources/templates.py

@@ -0,0 +1,80 @@
+"""Resource template functionality."""
+
+import inspect
+import re
+from typing import Any, Callable, Dict, Optional
+
+from pydantic import BaseModel, Field, TypeAdapter, validate_call
+
+from fastmcp.resources.types import FunctionResource, Resource
+
+
+class ResourceTemplate(BaseModel):
+    """A template for dynamically creating resources."""
+
+    uri_template: str = Field(
+        description="URI template with parameters (e.g. weather://{city}/current)"
+    )
+    name: str = Field(description="Name of the resource")
+    description: str | None = Field(description="Description of what the resource does")
+    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")
+
+    @classmethod
+    def from_function(
+        cls,
+        fn: Callable,
+        uri_template: str,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        mime_type: Optional[str] = None,
+    ) -> "ResourceTemplate":
+        """Create a template from a function."""
+        func_name = name or fn.__name__
+        if func_name == "<lambda>":
+            raise ValueError("You must provide a name for lambda functions")
+
+        # Get schema from TypeAdapter - will fail if function isn't properly typed
+        parameters = TypeAdapter(fn).json_schema()
+
+        # ensure the arguments are properly cast
+        fn = validate_call(fn)
+
+        return cls(
+            uri_template=uri_template,
+            name=func_name,
+            description=description or fn.__doc__ or "",
+            mime_type=mime_type or "text/plain",
+            fn=fn,
+            parameters=parameters,
+        )
+
+    def matches(self, uri: str) -> Optional[Dict[str, Any]]:
+        """Check if URI matches template and extract parameters."""
+        # Convert template to regex pattern
+        pattern = self.uri_template.replace("{", "(?P<").replace("}", ">[^/]+)")
+        match = re.match(f"^{pattern}$", uri)
+        if match:
+            return match.groupdict()
+        return None
+
+    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
+            result = self.fn(**params)
+            if inspect.iscoroutine(result):
+                result = await result
+
+            return FunctionResource(
+                uri=uri,
+                name=self.name,
+                description=self.description,
+                mime_type=self.mime_type,
+                fn=lambda: result,  # Capture result in closure
+            )
+        except Exception as e:
+            raise ValueError(f"Error creating resource from template: {e}")

fastmcp/resources/types.py

@@ -0,0 +1,171 @@
+"""Concrete resource implementations."""
+
+import asyncio
+import json
+from pathlib import Path
+from typing import Any, Callable, Union
+
+import httpx
+import pydantic.json
+import pydantic_core
+from pydantic import Field
+
+from fastmcp.resources.base import Resource
+
+
+class TextResource(Resource):
+    """A resource that reads from a string."""
+
+    text: str = Field(description="Text content of the resource")
+
+    async def read(self) -> str:
+        """Read the text content."""
+        return self.text
+
+
+class BinaryResource(Resource):
+    """A resource that reads from bytes."""
+
+    data: bytes = Field(description="Binary content of the resource")
+
+    async def read(self) -> bytes:
+        """Read the binary content."""
+        return self.data
+
+
+class FunctionResource(Resource):
+    """A resource that defers data loading by wrapping a function.
+
+    The function is only called when the resource is read, allowing for lazy loading
+    of potentially expensive data. This is particularly useful when listing resources,
+    as the function won't be called until the resource is actually accessed.
+
+    The function can return:
+    - str for text content (default)
+    - bytes for binary content
+    - other types will be converted to JSON
+    """
+
+    fn: Callable[[], Any] = Field(exclude=True)
+
+    async def read(self) -> Union[str, bytes]:
+        """Read the resource by calling the wrapped function."""
+        try:
+            result = self.fn()
+            if isinstance(result, Resource):
+                return await result.read()
+            if isinstance(result, bytes):
+                return result
+            if isinstance(result, str):
+                return result
+            try:
+                return json.dumps(pydantic_core.to_jsonable_python(result))
+            except (TypeError, pydantic_core.PydanticSerializationError):
+                # If JSON serialization fails, try str()
+                return str(result)
+        except Exception as e:
+            raise ValueError(f"Error reading resource {self.uri}: {e}")
+
+
+class FileResource(Resource):
+    """A resource that reads from a file.
+
+    Set is_binary=True to read file as binary data instead of text.
+    """
+
+    path: Path = Field(description="Path to the file")
+    is_binary: bool = Field(
+        default=False,
+        description="Whether to read the file as binary data",
+    )
+    mime_type: str = Field(
+        default="text/plain",
+        description="MIME type of the resource content",
+    )
+
+    @pydantic.field_validator("path")
+    @classmethod
+    def validate_absolute_path(cls, path: Path) -> Path:
+        """Ensure path is absolute."""
+        if not path.is_absolute():
+            raise ValueError("Path must be absolute")
+        return path
+
+    async def read(self) -> Union[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)
+        except Exception as e:
+            raise ValueError(f"Error reading file {self.path}: {e}")
+
+
+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(
+        default="application/json", description="MIME type of the resource content"
+    )
+
+    async def read(self) -> Union[str, bytes]:
+        """Read the HTTP content."""
+        async with httpx.AsyncClient() as client:
+            response = await client.get(self.url)
+            response.raise_for_status()
+            return response.text
+
+
+class DirectoryResource(Resource):
+    """A resource that lists files in a directory."""
+
+    path: Path = Field(description="Path to the directory")
+    recursive: bool = Field(
+        default=False, description="Whether to list files recursively"
+    )
+    pattern: str | None = Field(
+        default=None, description="Optional glob pattern to filter files"
+    )
+    mime_type: str | None = Field(
+        default="application/json", description="MIME type of the resource content"
+    )
+
+    @pydantic.field_validator("path")
+    @classmethod
+    def validate_absolute_path(cls, path: Path) -> Path:
+        """Ensure path is absolute."""
+        if not path.is_absolute():
+            raise ValueError("Path must be absolute")
+        return path
+
+    def list_files(self) -> list[Path]:
+        """List files in the directory."""
+        if not self.path.exists():
+            raise FileNotFoundError(f"Directory not found: {self.path}")
+        if not self.path.is_dir():
+            raise NotADirectoryError(f"Not a directory: {self.path}")
+
+        try:
+            if self.pattern:
+                return (
+                    list(self.path.glob(self.pattern))
+                    if not self.recursive
+                    else list(self.path.rglob(self.pattern))
+                )
+            return (
+                list(self.path.glob("*"))
+                if not self.recursive
+                else list(self.path.rglob("*"))
+            )
+        except Exception as e:
+            raise ValueError(f"Error listing directory {self.path}: {e}")
+
+    async def read(self) -> str:  # Always returns JSON string
+        """Read the directory listing."""
+        try:
+            files = await asyncio.to_thread(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:
+            raise ValueError(f"Error reading directory {self.path}: {e}")