mcp-proxy-adapter 2.1.11__py3-none-any.whl → 2.1.13__py3-none-any.whl

mcp_proxy_adapter/analyzers/__init__.py

@@ -1,14 +1 @@
-"""
-Analyzers for extracting metadata from functions and docstrings.
-
-This module contains classes for analyzing type annotations and docstrings
-of Python functions to automatically extract metadata for commands.
-"""
-
-from .type_analyzer import TypeAnalyzer
-from .docstring_analyzer import DocstringAnalyzer
-
-__all__ = [
-    'TypeAnalyzer',
-    'DocstringAnalyzer',
-] 
+ 

mcp_proxy_adapter/dispatchers/__init__.py

@@ -1,14 +1 @@
-"""
-Command dispatchers for registering and executing commands.
-
-This module contains base classes and implementations of command dispatchers
-that are responsible for registering and executing commands.
-"""
-
-from .base_dispatcher import BaseDispatcher
-from .json_rpc_dispatcher import JsonRpcDispatcher
-
-__all__ = [
-    'BaseDispatcher',
-    'JsonRpcDispatcher',
-] 
+ 

mcp_proxy_adapter/dispatchers/json_rpc_dispatcher.py

@@ -1,14 +1,20 @@
 """
 Implementation of a JSON-RPC based command dispatcher.
+
+CHANGELOG:
+- 2024-06-13: execute() now always returns awaitable. If handler is sync and for any reason result is not awaitable, it is wrapped in an async function and awaited. This guarantees await-safety for all handler types and fixes 'object ... can't be used in await expression' errors in all environments.
 """
 from typing import Dict, Any, Callable, List, Optional, Union
 import inspect
 import logging
 import traceback
 from .base_dispatcher import BaseDispatcher
+import asyncio
 
 logger = logging.getLogger("command_registry")
 
+print('[DEBUG] LOADED json_rpc_dispatcher.py')
+
 class CommandError(Exception):
     """Base class for command errors"""
     pass
@@ -27,6 +33,34 @@ class JsonRpcDispatcher(BaseDispatcher):
     
     Implements the BaseDispatcher interface for handling commands in JSON-RPC 2.0 format.
     Supports registration, execution, and retrieval of command information.
+
+    Best practice:
+    ----------------
+    Register handlers explicitly using register_handler (no decorators!).
+    Both sync and async handlers are supported.
+
+    Example:
+        import asyncio
+        from mcp_proxy_adapter.dispatchers.json_rpc_dispatcher import JsonRpcDispatcher
+
+        def sync_handler(x):
+            return x + 1
+
+        async def async_handler(x):
+            await asyncio.sleep(0.1)
+            return x * 2
+
+        dispatcher = JsonRpcDispatcher()
+        dispatcher.register_handler('sync', sync_handler, description='Sync handler')
+        dispatcher.register_handler('async', async_handler, description='Async handler')
+
+        # Call sync handler
+        result_sync = asyncio.run(dispatcher.execute('sync', x=10))
+        print(result_sync)  # 11
+
+        # Call async handler
+        result_async = asyncio.run(dispatcher.execute('async', x=10))
+        print(result_async)  # 20
     """
     
     def __init__(self):
@@ -38,10 +72,14 @@ class JsonRpcDispatcher(BaseDispatcher):
         self.register_handler(
             command="help",
             handler=self._help_command,
-            description="Returns information about available commands",
+            description=(
+                "Returns information about available commands.\n"
+                "Best practice: Register handlers explicitly using register_handler (no decorators).\n"
+                "Example: dispatcher.register_handler('mycmd', my_handler, description='...')"
+            ),
             summary="Command help",
             params={
-                "cmdname": {
+                "command": {
                     "type": "string",
                     "description": "Command name for detailed information",
                     "required": False
@@ -82,43 +120,41 @@ class JsonRpcDispatcher(BaseDispatcher):
         
         logger.debug(f"Registered command: {command}")
     
-    def execute(self, command: str, **kwargs) -> Any:
-        """
-        Executes a command with the specified parameters.
-        
-        Args:
-            command: Command name
-            **kwargs: Command parameters
-            
-        Returns:
-            Any: Command execution result
-            
-        Raises:
-            CommandNotFoundError: If command is not found
-            CommandExecutionError: On command execution error
-        """
+    async def _call_handler_always_awaitable(self, handler, kwargs):
+        loop = asyncio.get_running_loop()
+        sig = inspect.signature(handler)
+        params = sig.parameters
+        try:
+            if inspect.iscoroutinefunction(handler):
+                if len(params) == 1 and 'params' in params:
+                    result = handler(params=kwargs)
+                else:
+                    result = handler(**kwargs)
+            else:
+                if len(params) == 1 and 'params' in params:
+                    result = loop.run_in_executor(None, lambda: handler(params=kwargs))
+                else:
+                    result = loop.run_in_executor(None, lambda: handler(**kwargs))
+            if inspect.isawaitable(result):
+                return await result
+            else:
+                async def _return_sync():
+                    return result
+                return await _return_sync()
+        except Exception as e:
+            raise e
+
+    async def execute(self, command: str, **kwargs) -> Any:
         # Check if command exists
         if command not in self._handlers:
             raise CommandNotFoundError(f"Command '{command}' not found")
-        
         handler = self._handlers[command]
-        
         try:
-            # Get function signature
-            sig = inspect.signature(handler)
-            
-            # If function accepts params dictionary, pass all parameters in it
-            if len(sig.parameters) == 1 and list(sig.parameters.keys())[0] == 'params':
-                return handler(params=kwargs)
-            
-            # Otherwise pass parameters as named arguments
-            return handler(**kwargs)
+            result = await self._call_handler_always_awaitable(handler, kwargs)
+            return result
         except Exception as e:
-            # Log the error
             logger.error(f"Error executing command '{command}': {str(e)}")
             logger.debug(traceback.format_exc())
-            
-            # Re-raise the exception
             raise CommandExecutionError(f"Error executing command '{command}': {str(e)}")
     
     def get_valid_commands(self) -> List[str]:
@@ -160,7 +196,7 @@ class JsonRpcDispatcher(BaseDispatcher):
         
         Args:
             params: Command parameters
-                cmdname: Command name for detailed information
+                command: Command name for detailed information
                 
         Returns:
             Dict[str, Any]: Command help information
@@ -168,18 +204,18 @@ class JsonRpcDispatcher(BaseDispatcher):
         if not params:
             params = {}
             
-        # Only support 'cmdname' parameter
-        if "cmdname" in params and params["cmdname"]:
-            cmdname = params["cmdname"]
-            if cmdname not in self._metadata:
+        # If specific command is specified, return information only about it
+        if "command" in params and params["command"]:
+            command = params["command"]
+            if command not in self._metadata:
                 return {
-                    "error": f"Command '{cmdname}' not found",
+                    "error": f"Command '{command}' not found",
                     "available_commands": list(self._metadata.keys())
                 }
             
             return {
-                "cmdname": cmdname,
-                "info": self._metadata[cmdname]
+                "command": command,
+                "info": self._metadata[command]
             }
         
         # Otherwise return brief information about all commands
@@ -194,5 +230,5 @@ class JsonRpcDispatcher(BaseDispatcher):
         return {
             "commands": commands_info,
             "total": len(commands_info),
-            "note": "To get info about a specific command, call help with parameter: POST /cmd {\"command\": \"help\", \"params\": {\"cmdname\": \"<command_name>\"}}. Only the 'cmdname' parameter is supported. Calling 'help <command>' (with space) is NOT supported."
+            "note": "Use the 'command' parameter to get detailed information about a specific command"
         } 

mcp_proxy_adapter/examples/basic_integration.py

@@ -14,14 +14,8 @@ if parent_dir not in sys.path:
 
 from fastapi import FastAPI, HTTPException, APIRouter
 from pydantic import BaseModel
-
-# Import from installed package or local file
-try:
-    from mcp_proxy_adapter.adapter import MCPProxyAdapter, configure_logger
-    from mcp_proxy_adapter.registry import CommandRegistry
-except ImportError:
-    from src.adapter import MCPProxyAdapter, configure_logger
-    from src.registry import CommandRegistry
+from mcp_proxy_adapter.adapter import MCPProxyAdapter, configure_logger
+from mcp_proxy_adapter.registry import CommandRegistry
 
 # Configure project logging
 logging.basicConfig(

mcp_proxy_adapter/examples/help_usage.py

@@ -24,29 +24,29 @@ registry = MockRegistry()
 adapter = MCPProxyAdapter(registry)
 
 # --- Best practice: always check if 'help' is in commands ---
-def call_help(cmdname: str = None) -> Dict[str, Any]:
+def call_help(command: str = None) -> Dict[str, Any]:
     """Call help command with or without parameter."""
     dispatcher = registry.dispatcher
     if "help" in dispatcher.get_valid_commands():
-        if cmdname:
+        if command:
             try:
-                return dispatcher.help_command(cmdname=cmdname)
+                return dispatcher.help_command(command=command)
             except Exception as e:
                 print(f"Project help failed: {e}. Fallback to adapter help.")
-                return adapter_help(cmdname)
+                return adapter_help(command)
         else:
             return dispatcher.help_command()
     else:
-        return adapter_help(cmdname)
+        return adapter_help(command)
 
-def adapter_help(cmdname: str = None) -> Dict[str, Any]:
+def adapter_help(command: str = None) -> Dict[str, Any]:
     """Fallback: call adapter's help (simulate)."""
     dispatcher = registry.dispatcher
-    if not cmdname:
+    if not command:
         return {"source": "adapter", "commands": dispatcher.get_valid_commands()}
-    if cmdname in dispatcher.get_valid_commands():
-        return {"source": "adapter", "cmdname": cmdname, "info": {"description": "Adapter help for command"}}
-    return {"source": "adapter", "error": f"Command '{cmdname}' not found (adapter)", "available_commands": dispatcher.get_valid_commands()}
+    if command in dispatcher.get_valid_commands():
+        return {"source": "adapter", "command": command, "info": {"description": "Adapter help for command"}}
+    return {"source": "adapter", "error": f"Command '{command}' not found (adapter)", "available_commands": dispatcher.get_valid_commands()}
 
 if __name__ == "__main__":
     print("=== Project help (no param) ===")

mcp_proxy_adapter/examples/openapi_server.py

@@ -171,7 +171,7 @@ class MockDispatcher:
             "help": {
                 "description": "Show information about available commands or a specific command.",
                 "params": {
-                    "cmdname": {
+                    "command": {
                         "type": "string",
                         "description": "Command name for detailed info",
                         "required": False
@@ -278,18 +278,19 @@ class MockDispatcher:
 
     def help_command(self, **params):
         """Return info about all commands or a specific command."""
-        cmdname = params.get("cmdname")
-        if cmdname:
-            info = self.commands_info.get(cmdname)
+        # Если в будущем появится пользовательская команда help, можно реализовать её здесь
+        command = params.get("command")
+        if command:
+            info = self.commands_info.get(command)
             if info:
-                return {"cmdname": cmdname, "info": info}
+                return {"command": command, "info": info}
             else:
-                return {"error": f"Command '{cmdname}' not found", "available_commands": list(self.commands_info.keys())}
-        # Если параметр cmdname не указан, возвращаем краткую информацию обо всех
+                return {"error": f"Command '{command}' not found", "available_commands": list(self.commands_info.keys())}
+        # Если параметр command не указан, возвращаем краткую информацию обо всех
         return {
             "commands": {cmd: {"description": info["description"], "params": info["params"]} for cmd, info in self.commands_info.items()},
             "total": len(self.commands_info),
-            "note": "Use the 'cmdname' parameter to get detailed information about a specific command"
+            "note": "Use the 'command' parameter to get detailed information about a specific command"
         }
 
 # --- Создание registry и FastAPI-приложения на верхнем уровне ---

mcp_proxy_adapter-2.1.13.dist-info/METADATA

@@ -0,0 +1,341 @@
+Metadata-Version: 2.4
+Name: mcp-proxy-adapter
+Version: 2.1.13
+Summary: Adapter for exposing Command Registry commands as tools for AI models via MCP Proxy.
+Home-page: https://github.com/vasilyvz/mcp-proxy-adapter
+Author: Vasiliy VZ
+Author-email: Vasiliy VZ <vasilyvz@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/vasilyvz/mcp-proxy-adapter
+Project-URL: Bug Tracker, https://github.com/vasilyvz/mcp-proxy-adapter/issues
+Project-URL: Documentation, https://github.com/vasilyvz/mcp-proxy-adapter/tree/main/docs
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9, <4
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi<1.0.0,>=0.95.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: uvicorn<1.0.0,>=0.22.0
+Requires-Dist: docstring-parser<1.0.0,>=0.15
+Requires-Dist: typing-extensions<5.0.0,>=4.5.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# MCP Proxy Adapter
+
+Adapter for integrating [Command Registry](docs/README.md) with MCP Proxy, allowing you to use commands as tools for AI models.
+
+## Overview
+
+MCP Proxy Adapter transforms commands registered in the Command Registry into a format compatible with MCP Proxy. This enables:
+
+1. Using existing commands as tools for AI models
+2. Creating a hybrid REST/JSON-RPC API for command execution
+3. Automatic generation of OpenAPI schemas optimized for MCP Proxy
+4. Managing tool metadata for better AI system integration
+
+## Installation
+
+```bash
+pip install mcp-proxy-adapter
+```
+
+## Quick Start
+
+```python
+from mcp_proxy_adapter import MCPProxyAdapter, CommandRegistry
+from fastapi import FastAPI
+
+# Create a command registry instance
+registry = CommandRegistry()
+
+# Register commands
+def calculate_total(prices: list[float], discount: float = 0.0) -> float:
+    """
+    Calculates the total price with discount.
+    Args:
+        prices: List of item prices
+        discount: Discount percentage (0-100)
+    Returns:
+        Total price with discount
+    """
+    subtotal = sum(prices)
+    return subtotal * (1 - discount / 100)
+
+registry.register_command("calculate_total", calculate_total)
+
+# Create FastAPI app
+app = FastAPI()
+
+# Create and configure MCP Proxy adapter
+adapter = MCPProxyAdapter(registry)
+
+# Register endpoints in FastAPI app
+adapter.register_endpoints(app)
+
+# Generate and save MCP Proxy config
+adapter.save_config_to_file("mcp_proxy_config.json")
+```
+
+## Supported Request Formats
+
+The adapter supports three request formats for command execution:
+
+### 1. JSON-RPC format
+
+```json
+{
+  "jsonrpc": "2.0",
+  "method": "command_name",
+  "params": {
+    "param1": "value1",
+    "param2": "value2"
+  },
+  "id": 1
+}
+```
+
+Example request to `/cmd` endpoint:
+
+```bash
+curl -X POST -H "Content-Type: application/json" -d '{
+  "jsonrpc": "2.0",
+  "method": "calculate_total",
+  "params": {
+    "prices": [100, 200, 300],
+    "discount": 10
+  },
+  "id": 1
+}' http://localhost:8000/cmd
+```
+
+Response:
+
+```json
+{
+  "jsonrpc": "2.0",
+  "result": 540.0,
+  "id": 1
+}
+```
+
+### 2. MCP Proxy format
+
+```json
+{
+  "command": "command_name",
+  "params": {
+    "param1": "value1",
+    "param2": "value2"
+  }
+}
+```
+
+Example request:
+
+```bash
+curl -X POST -H "Content-Type: application/json" -d '{
+  "command": "calculate_total",
+  "params": {
+    "prices": [100, 200, 300],
+    "discount": 10
+  }
+}' http://localhost:8000/cmd
+```
+
+Response:
+
+```json
+{
+  "result": 540.0
+}
+```
+
+### 3. Params-only format
+
+```json
+{
+  "params": {
+    "command": "command_name",
+    "param1": "value1",
+    "param2": "value2"
+  }
+}
+```
+
+or
+
+```json
+{
+  "params": {
+    "query": "command_name",
+    "param1": "value1",
+    "param2": "value2"
+  }
+}
+```
+
+Example request:
+
+```bash
+curl -X POST -H "Content-Type: application/json" -d '{
+  "params": {
+    "command": "calculate_total",
+    "prices": [100, 200, 300],
+    "discount": 10
+  }
+}' http://localhost:8000/cmd
+```
+
+Response:
+
+```json
+{
+  "result": 540.0
+}
+```
+
+## Full Example: Integration with FastAPI
+
+```python
+import logging
+from fastapi import FastAPI, APIRouter
+from mcp_proxy_adapter import CommandRegistry, MCPProxyAdapter, configure_logger
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+project_logger = logging.getLogger("my_project")
+
+# Create FastAPI app
+app = FastAPI(title="My API with MCP Proxy Integration")
+
+# Create existing API router
+router = APIRouter()
+
+@router.get("/items")
+async def get_items():
+    """Returns a list of items."""
+    return [
+        {"id": 1, "name": "Smartphone X", "price": 999.99},
+        {"id": 2, "name": "Laptop Y", "price": 1499.99},
+    ]
+
+app.include_router(router)
+
+# Register commands
+registry = CommandRegistry()
+
+def get_discounted_price(price: float, discount: float = 0.0) -> float:
+    """
+    Returns the price after applying a discount.
+    """
+    return price * (1 - discount / 100)
+
+registry.register_command("get_discounted_price", get_discounted_price)
+
+# Create and register MCP Proxy adapter
+adapter = MCPProxyAdapter(registry)
+adapter.register_endpoints(app)
+
+# Save MCP Proxy config
+adapter.save_config_to_file("mcp_proxy_config.json")
+```
+
+## Features
+- Universal JSON-RPC endpoint for command execution
+- Automatic OpenAPI schema generation and optimization for MCP Proxy
+- Tool metadata for AI models
+- Customizable endpoints and logging
+- Full test coverage and examples
+
+## FAQ
+
+**Q: Почему не удаётся использовать декоратор @registry.command для регистрации команд?**
+A: В последних версиях пакета декоратор @registry.command больше не поддерживается. Теперь команды регистрируются только явно, через вызов метода:
+
+```python
+registry.register_command("имя_команды", функция)
+```
+
+**Q: Почему не удаётся импортировать CommandRegistry напрямую из mcp_proxy_adapter?**
+A: Класс CommandRegistry находится в подмодуле registry. Используйте:
+
+```python
+from mcp_proxy_adapter.registry import CommandRegistry
+```
+
+**Q: Какой способ импорта MCPProxyAdapter и configure_logger?**
+A: Импортируйте их из подмодуля adapter:
+
+```python
+from mcp_proxy_adapter.adapter import MCPProxyAdapter, configure_logger
+```
+
+**Q: Как добавить свою команду?**
+A: Зарегистрируйте функцию через registry.register_command или декоратор (см. примеры выше).
+
+**Q: Как получить OpenAPI-схему?**
+A: После регистрации адаптера вызовите /openapi.json в вашем FastAPI-приложении.
+
+**Q: Какой формат запроса поддерживается?**
+A: JSON-RPC, MCP Proxy и params-only (см. раздел Supported Request Formats).
+
+## HOWTO
+
+**Как интегрировать MCP Proxy Adapter с FastAPI:**
+1. Установите пакет:
+   ```bash
+   pip install mcp-proxy-adapter
+   ```
+2. Импортируйте нужные классы:
+   ```python
+   from mcp_proxy_adapter.registry import CommandRegistry
+   from mcp_proxy_adapter.adapter import MCPProxyAdapter
+   ```
+3. Зарегистрируйте команды и настройте FastAPI:
+   ```python
+   registry = CommandRegistry()
+   registry.register_command("my_command", my_function)
+   app = FastAPI()
+   adapter = MCPProxyAdapter(registry)
+   adapter.register_endpoints(app)
+   ```
+4. (Опционально) Сохраните конфиг для MCP Proxy:
+   ```python
+   adapter.save_config_to_file("mcp_proxy_config.json")
+   ```
+
+**Как добавить поддержку кастомного логгера:**
+```python
+import logging
+from mcp_proxy_adapter.adapter import configure_logger
+logger = logging.getLogger("my_project")
+adapter_logger = configure_logger(logger)
+```
+
+**Как получить список всех команд через API:**
+Вызовите GET `/api/commands` на вашем сервере FastAPI.
+
+## License
+MIT
+
+## Documentation
+See [docs/](docs/) for detailed guides, architecture, and examples.
+
+## CI/CD & PyPI automation
+
+This project uses GitHub Actions for continuous integration and automated publishing to PyPI.
+
+- All tests are run on every push and pull request.
+- On push of a new tag (vX.Y.Z), the package is built and published to PyPI automatically.
+
+See `.github/workflows/publish.yml` for details. 

mcp_proxy_adapter-2.1.13.dist-info/RECORD

@@ -0,0 +1,19 @@
+mcp_proxy_adapter/testing_utils.py,sha256=RWjQFNSUtVkeP0qNzp6_jrT6_tub3w_052DrRmvxVk0,4243
+mcp_proxy_adapter/analyzers/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
+mcp_proxy_adapter/dispatchers/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
+mcp_proxy_adapter/dispatchers/json_rpc_dispatcher.py,sha256=Ibp-4d4kKf_AW_yv_27Zb_PgFIfa3tZLmuppMg8YqsY,8034
+mcp_proxy_adapter/examples/analyze_config.py,sha256=vog7TNHDw5ZoYhQLbAvZvEoufmQwH54KJzQBJrSq5w4,4283
+mcp_proxy_adapter/examples/basic_integration.py,sha256=mtRval4VSUgTb_C2p8U_DPPSEKA08dZYKZk-bOrE4H4,4470
+mcp_proxy_adapter/examples/docstring_and_schema_example.py,sha256=c96L4KF_7yWzffmvd4hyeQuXSdYyYkv7Uvuy0QxgMcQ,1929
+mcp_proxy_adapter/examples/extension_example.py,sha256=vnatnFdNTapMpPcQ79Ugitk92ZiUfpLTs7Dvsodf1og,2277
+mcp_proxy_adapter/examples/help_best_practices.py,sha256=Bit9Ywl9vGvM_kuV8DJ6pIDK4mY4mF2Gia9rLc56RpI,2646
+mcp_proxy_adapter/examples/help_usage.py,sha256=JIUsZofdLFyI7FcwPF-rLxipF1-HaZINzVK1KBh0vxA,2577
+mcp_proxy_adapter/examples/mcp_proxy_client.py,sha256=z4IzFlGigVTQSb8TpcrQ_a0migsmC58LnNwc8wZmTfw,3811
+mcp_proxy_adapter/examples/openapi_server.py,sha256=5gRM-EHvMsnNtS_M6l_pNPN5EkSf4X1Lcq4E1Xs5tp0,13387
+mcp_proxy_adapter/examples/project_structure_example.py,sha256=sswTo6FZb1F5juHa0FYG3cgvrh3wfgGfJu2bBy5tCm4,1460
+mcp_proxy_adapter/examples/testing_example.py,sha256=AB13c4C1bjs1145O-yriwyreeVXtMOlQLzs2BCGmprk,1719
+mcp_proxy_adapter-2.1.13.dist-info/licenses/LICENSE,sha256=OkApFEwdgMCt_mbvUI-eIwKMSTe38K3XnU2DT5ub-wI,1072
+mcp_proxy_adapter-2.1.13.dist-info/METADATA,sha256=1flBa3KLq1QMMf9T-NcpgpP3LxJY4_BwMAUW21K915Q,8886
+mcp_proxy_adapter-2.1.13.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+mcp_proxy_adapter-2.1.13.dist-info/top_level.txt,sha256=JZT7vPLBYrtroX-ij68JBhJYbjDdghcV-DFySRy-Nnw,18
+mcp_proxy_adapter-2.1.13.dist-info/RECORD,,

{mcp_proxy_adapter-2.1.11.dist-info → mcp_proxy_adapter-2.1.13.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any