aiomcp-server-time 0.0.1__tar.gz

aiomcp_server_time-0.0.1/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: aiomcp-server-time
+Version: 0.0.1
+Summary: Time and timezone conversion MCP server powered by aiomcp
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: aiomcp
+Requires-Dist: pydantic
+Requires-Dist: tzlocal
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"

aiomcp_server_time-0.0.1/aiomcp_server_time/__main__.py

@@ -0,0 +1,29 @@
+def main() -> None:
+    import argparse
+    import asyncio
+
+    from aiomcp_server_time.server import host_http, host_stdio
+
+    parser = argparse.ArgumentParser(
+        description="Time and timezone conversion MCP server."
+    )
+    parser.add_argument(
+        "--http",
+        metavar="URL",
+        help="Host an HTTP MCP endpoint at URL instead of using stdio.",
+    )
+    parser.add_argument("--local-timezone", type=str, help="Override local timezone")
+
+    args = parser.parse_args()
+
+    try:
+        if args.http:
+            asyncio.run(host_http(args.http, local_timezone=args.local_timezone))
+        else:
+            asyncio.run(host_stdio(local_timezone=args.local_timezone))
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

aiomcp_server_time-0.0.1/aiomcp_server_time/server.py

@@ -0,0 +1,165 @@
+from datetime import datetime, timedelta
+from typing import Annotated, Any
+
+from aiomcp import McpServer
+from aiomcp.transports.stdio import McpStdioServerTransport
+from pydantic import BaseModel, Field
+from tzlocal import get_localzone_name
+from zoneinfo import ZoneInfo
+
+
+class TimeResult(BaseModel):
+    timezone: str
+    datetime: str
+    day_of_week: str
+    is_dst: bool
+
+
+class TimeConversionResult(BaseModel):
+    source: TimeResult
+    target: TimeResult
+    time_difference: str
+
+
+TIME_TOOL_ANNOTATIONS = {
+    "readOnlyHint": True,
+    "destructiveHint": False,
+    "idempotentHint": True,
+    "openWorldHint": False,
+}
+
+
+SERVER_NAME = "aiomcp-time-server"
+
+
+def get_timezone(timezone_name: str) -> ZoneInfo:
+    try:
+        return ZoneInfo(timezone_name)
+    except Exception as exc:
+        raise ValueError(f"Invalid timezone: {exc}") from exc
+
+
+def get_local_timezone(local_timezone_override: str | None = None) -> ZoneInfo:
+    if local_timezone_override:
+        return get_timezone(local_timezone_override)
+
+    local_timezone_name = get_localzone_name()
+    if local_timezone_name is not None:
+        return get_timezone(local_timezone_name)
+    return ZoneInfo("UTC")
+
+
+def get_current_time(
+    timezone: Annotated[
+        str,
+        Field(
+            description="IANA timezone name (e.g., 'America/New_York', 'Europe/London'). Use '{CURRENT_TIMEZONE}' as local timezone if no timezone provided by the user."
+        ),
+    ],
+) -> Any:
+    resolved_timezone = get_timezone(timezone)
+    current_time = datetime.now(resolved_timezone)
+
+    return TimeResult(
+        timezone=timezone,
+        datetime=current_time.isoformat(timespec="seconds"),
+        day_of_week=current_time.strftime("%A"),
+        is_dst=bool(current_time.dst()),
+    )
+
+
+def convert_time(
+    source_timezone: Annotated[
+        str,
+        Field(
+            description="Source IANA timezone name (e.g., 'America/New_York', 'Europe/London'). Use '{CURRENT_TIMEZONE}' as local timezone if no source timezone provided by the user."
+        ),
+    ],
+    time: Annotated[
+        str,
+        Field(description="Time to convert in 24-hour format (HH:MM)"),
+    ],
+    target_timezone: Annotated[
+        str,
+        Field(
+            description="Target IANA timezone name (e.g., 'Asia/Tokyo', 'America/San_Francisco'). Use '{CURRENT_TIMEZONE}' as local timezone if no target timezone provided by the user."
+        ),
+    ],
+) -> Any:
+    resolved_source_timezone = get_timezone(source_timezone)
+    resolved_target_timezone = get_timezone(target_timezone)
+
+    try:
+        parsed_time = datetime.strptime(time, "%H:%M").time()
+    except ValueError as exc:
+        raise ValueError(
+            "Invalid time format. Expected HH:MM [24-hour format]"
+        ) from exc
+
+    now = datetime.now(resolved_source_timezone)
+    source_time = datetime(
+        now.year,
+        now.month,
+        now.day,
+        parsed_time.hour,
+        parsed_time.minute,
+        tzinfo=resolved_source_timezone,
+    )
+    target_time = source_time.astimezone(resolved_target_timezone)
+
+    source_offset = source_time.utcoffset() or timedelta()
+    target_offset = target_time.utcoffset() or timedelta()
+    hours_difference = (target_offset - source_offset).total_seconds() / 3600
+    if hours_difference.is_integer():
+        time_difference = f"{hours_difference:+.1f}h"
+    else:
+        time_difference = f"{hours_difference:+.2f}".rstrip("0").rstrip(".") + "h"
+
+    return TimeConversionResult(
+        source=TimeResult(
+            timezone=source_timezone,
+            datetime=source_time.isoformat(timespec="seconds"),
+            day_of_week=source_time.strftime("%A"),
+            is_dst=bool(source_time.dst()),
+        ),
+        target=TimeResult(
+            timezone=target_timezone,
+            datetime=target_time.isoformat(timespec="seconds"),
+            day_of_week=target_time.strftime("%A"),
+            is_dst=bool(target_time.dst()),
+        ),
+        time_difference=time_difference,
+    )
+
+
+async def register_tools(server: McpServer, local_timezone: str | None = None) -> None:
+    resolved_local_timezone = str(get_local_timezone(local_timezone))
+    format_map = {"CURRENT_TIMEZONE": resolved_local_timezone}
+
+    await server.register_tool(
+        func=get_current_time,
+        description="Get current time in a specific timezones",
+        annotations=TIME_TOOL_ANNOTATIONS,
+        format_map=format_map,
+    )
+    await server.register_tool(
+        func=convert_time,
+        description="Convert time between timezones",
+        annotations=TIME_TOOL_ANNOTATIONS,
+        format_map=format_map,
+    )
+
+
+async def host_stdio(local_timezone: str | None = None) -> None:
+    server = McpServer(SERVER_NAME)
+    await register_tools(server, local_timezone=local_timezone)
+
+    transport = McpStdioServerTransport()
+    await server.host(transport)
+
+
+async def host_http(url: str, local_timezone: str | None = None) -> None:
+    server = McpServer(SERVER_NAME)
+    await register_tools(server, local_timezone=local_timezone)
+
+    await server.host(url)

aiomcp_server_time-0.0.1/aiomcp_server_time.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: aiomcp-server-time
+Version: 0.0.1
+Summary: Time and timezone conversion MCP server powered by aiomcp
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: aiomcp
+Requires-Dist: pydantic
+Requires-Dist: tzlocal
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"

aiomcp_server_time-0.0.1/aiomcp_server_time.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+aiomcp_server_time/__main__.py
+aiomcp_server_time/server.py
+aiomcp_server_time.egg-info/PKG-INFO
+aiomcp_server_time.egg-info/SOURCES.txt
+aiomcp_server_time.egg-info/dependency_links.txt
+aiomcp_server_time.egg-info/entry_points.txt
+aiomcp_server_time.egg-info/requires.txt
+aiomcp_server_time.egg-info/top_level.txt
+tests/test_time_server.py

aiomcp_server_time-0.0.1/aiomcp_server_time.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aiomcp_server_time-0.0.1/aiomcp_server_time.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aiomcp-server-time = aiomcp_server_time.__main__:main

aiomcp_server_time-0.0.1/aiomcp_server_time.egg-info/requires.txt

@@ -0,0 +1,7 @@
+aiomcp
+pydantic
+tzlocal
+
+[test]
+pytest
+pytest-asyncio

aiomcp_server_time-0.0.1/aiomcp_server_time.egg-info/top_level.txt

@@ -0,0 +1 @@
+aiomcp_server_time

aiomcp_server_time-0.0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "aiomcp-server-time"
+description = "Time and timezone conversion MCP server powered by aiomcp"
+version = "0.0.1"
+requires-python = ">=3.11"
+readme = "README.md"
+license = { text = "MIT" }
+dependencies = [
+    "aiomcp",
+    "pydantic",
+    "tzlocal",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "pytest-asyncio",
+]
+
+[project.scripts]
+aiomcp-server-time = "aiomcp_server_time.__main__:main"
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["aiomcp_server_time*"]

aiomcp_server_time-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aiomcp_server_time-0.0.1/tests/test_time_server.py

@@ -0,0 +1,223 @@
+import json
+import re
+from datetime import datetime
+from unittest.mock import patch
+
+import pytest
+
+from aiomcp import McpClient, McpServer
+from aiomcp_server_time.server import (
+    SERVER_NAME,
+    convert_time,
+    get_current_time,
+    get_local_timezone,
+    register_tools,
+)
+
+
+def freeze_time(test_time: str):
+    frozen_time = datetime.fromisoformat(test_time)
+
+    class FrozenDateTime(datetime):
+        @classmethod
+        def now(cls, timezone=None):
+            if timezone is None:
+                return frozen_time.replace(tzinfo=None)
+            return frozen_time.astimezone(timezone)
+
+    return patch("aiomcp_server_time.server.datetime", FrozenDateTime)
+
+
+async def create_test_server(local_timezone: str | None = None) -> McpServer:
+    server = McpServer(SERVER_NAME)
+    await register_tools(server, local_timezone=local_timezone)
+    return server
+
+
+@pytest.mark.parametrize(
+    ("test_time", "timezone", "expected"),
+    [
+        (
+            "2024-01-01 12:00:00+00:00",
+            "Europe/Warsaw",
+            {
+                "timezone": "Europe/Warsaw",
+                "datetime": "2024-01-01T13:00:00+01:00",
+                "day_of_week": "Monday",
+                "is_dst": False,
+            },
+        ),
+        (
+            "2024-03-31 12:00:00+00:00",
+            "America/New_York",
+            {
+                "timezone": "America/New_York",
+                "datetime": "2024-03-31T08:00:00-04:00",
+                "day_of_week": "Sunday",
+                "is_dst": True,
+            },
+        ),
+    ],
+)
+def test_get_current_time(test_time, timezone, expected):
+    with freeze_time(test_time):
+        result = get_current_time(timezone)
+
+    assert result.model_dump() == expected
+
+
+@pytest.mark.parametrize(
+    ("test_time", "source_timezone", "time_str", "target_timezone", "expected"),
+    [
+        (
+            "2024-01-01 00:00:00+00:00",
+            "Europe/London",
+            "12:00",
+            "Europe/Warsaw",
+            {
+                "source": {
+                    "timezone": "Europe/London",
+                    "datetime": "2024-01-01T12:00:00+00:00",
+                    "day_of_week": "Monday",
+                    "is_dst": False,
+                },
+                "target": {
+                    "timezone": "Europe/Warsaw",
+                    "datetime": "2024-01-01T13:00:00+01:00",
+                    "day_of_week": "Monday",
+                    "is_dst": False,
+                },
+                "time_difference": "+1.0h",
+            },
+        ),
+        (
+            "2024-01-01 00:00:00+00:00",
+            "Europe/Warsaw",
+            "12:00",
+            "Asia/Kathmandu",
+            {
+                "source": {
+                    "timezone": "Europe/Warsaw",
+                    "datetime": "2024-01-01T12:00:00+01:00",
+                    "day_of_week": "Monday",
+                    "is_dst": False,
+                },
+                "target": {
+                    "timezone": "Asia/Kathmandu",
+                    "datetime": "2024-01-01T16:45:00+05:45",
+                    "day_of_week": "Monday",
+                    "is_dst": False,
+                },
+                "time_difference": "+4.75h",
+            },
+        ),
+    ],
+)
+def test_convert_time(test_time, source_timezone, time_str, target_timezone, expected):
+    with freeze_time(test_time):
+        result = convert_time(source_timezone, time_str, target_timezone)
+
+    assert result.model_dump() == expected
+
+
+@pytest.mark.parametrize(
+    ("source_timezone", "time_str", "target_timezone", "expected_error"),
+    [
+        (
+            "invalid_timezone",
+            "12:00",
+            "Europe/London",
+            "Invalid timezone: 'No time zone found with key invalid_timezone'",
+        ),
+        (
+            "Europe/Warsaw",
+            "25:00",
+            "Europe/London",
+            "Invalid time format. Expected HH:MM [24-hour format]",
+        ),
+    ],
+)
+def test_convert_time_errors(
+    source_timezone, time_str, target_timezone, expected_error
+):
+    with pytest.raises(ValueError, match=re.escape(expected_error)):
+        convert_time(source_timezone, time_str, target_timezone)
+
+
+def test_get_local_timezone_with_override():
+    assert str(get_local_timezone("America/New_York")) == "America/New_York"
+
+
+@patch("aiomcp_server_time.server.get_localzone_name")
+def test_get_local_timezone_defaults_to_utc(mock_get_localzone):
+    mock_get_localzone.return_value = None
+
+    assert str(get_local_timezone()) == "UTC"
+
+
+@pytest.mark.asyncio
+async def test_aiomcp_server_exposes_reference_tools():
+    server = await create_test_server("Europe/Warsaw")
+    tools = await server.list_tools()
+    tool_names = {tool.name for tool in tools}
+
+    assert tool_names == {"get_current_time", "convert_time"}
+
+    current_time_tool = next(tool for tool in tools if tool.name == "get_current_time")
+    assert current_time_tool.description == "Get current time in a specific timezones"
+    assert current_time_tool.outputSchema is None
+    current_time_input_schema = current_time_tool.inputSchema.model_dump(
+        exclude_none=True
+    )
+    assert current_time_input_schema["properties"]["timezone"]["description"] == (
+        "IANA timezone name (e.g., 'America/New_York', 'Europe/London'). "
+        "Use 'Europe/Warsaw' as local timezone if no timezone provided by the user."
+    )
+
+    convert_tool = next(tool for tool in tools if tool.name == "convert_time")
+    assert convert_tool.outputSchema is None
+    input_schema = convert_tool.inputSchema.model_dump(exclude_none=True)
+    annotations = convert_tool.annotations.model_dump(exclude_none=True)
+    assert input_schema["required"] == ["source_timezone", "time", "target_timezone"]
+    assert input_schema["properties"]["source_timezone"]["description"] == (
+        "Source IANA timezone name (e.g., 'America/New_York', 'Europe/London'). "
+        "Use 'Europe/Warsaw' as local timezone if no source timezone provided by the user."
+    )
+    assert input_schema["properties"]["time"]["description"] == (
+        "Time to convert in 24-hour format (HH:MM)"
+    )
+    assert input_schema["properties"]["target_timezone"]["description"] == (
+        "Target IANA timezone name (e.g., 'Asia/Tokyo', 'America/San_Francisco'). "
+        "Use 'Europe/Warsaw' as local timezone if no target timezone provided by the user."
+    )
+    assert annotations == {
+        "readOnlyHint": True,
+        "destructiveHint": False,
+        "idempotentHint": True,
+        "openWorldHint": False,
+    }
+
+
+@pytest.mark.asyncio
+async def test_aiomcp_client_can_call_convert_time():
+    server = await create_test_server()
+    client = McpClient()
+    await client.initialize(server)
+
+    try:
+        with freeze_time("2024-01-01 00:00:00+00:00"):
+            result = await client.invoke(
+                "convert_time",
+                {
+                    "source_timezone": "Europe/Warsaw",
+                    "time": "12:00",
+                    "target_timezone": "Asia/Kathmandu",
+                },
+            )
+    finally:
+        await client.close()
+
+    assert result[0]["type"] == "text"
+    payload = json.loads(result[0]["text"])
+    assert payload["target"]["datetime"] == "2024-01-01T16:45:00+05:45"
+    assert payload["time_difference"] == "+4.75h"