sunholo 0.143.1__py3-none-any.whl → 0.143.7__py3-none-any.whl

sunholo/agents/flask/vac_routes.py

@@ -38,12 +38,19 @@ except ImportError:
 
 try:
     from ...mcp.vac_mcp_server import VACMCPServer
-    from mcp.server.models import InitializationOptions
-    from mcp import JSONRPCMessage, ErrorData, INTERNAL_ERROR
+    from mcp.server import Server
+    from mcp.types import JSONRPCMessage, ErrorData, INTERNAL_ERROR
 except ImportError:
     VACMCPServer = None
-    InitializationOptions = None
+    Server = None
     JSONRPCMessage = None
+    ErrorData = None
+    INTERNAL_ERROR = None
+
+try:
+    from ...a2a.vac_a2a_agent import VACA2AAgent
+except (ImportError, SyntaxError):
+    VACA2AAgent = None
 
 
 # Cache dictionary to store validated API keys
@@ -81,7 +88,9 @@ if __name__ == "__main__":
                  mcp_servers: List[Dict[str, Any]] = None,
                  async_stream:bool=False,
                  add_langfuse_eval:bool=True,
-                 enable_mcp_server:bool=False):
+                 enable_mcp_server:bool=False,
+                 enable_a2a_agent:bool=False,
+                 a2a_vac_names: List[str] = None):
         self.app = app
         self.stream_interpreter = stream_interpreter
         self.vac_interpreter = vac_interpreter or partial(self.vac_interpreter_default)
@@ -102,6 +111,15 @@ if __name__ == "__main__":
                 vac_interpreter=self.vac_interpreter
             )
 
+        # A2A agent initialization  
+        self.enable_a2a_agent = enable_a2a_agent
+        self.vac_a2a_agent = None
+        self.a2a_vac_names = a2a_vac_names
+        if self.enable_a2a_agent and VACA2AAgent:
+            # Extract base URL from request context during route handling
+            # For now, initialize with placeholder - will be updated in route handlers
+            self.vac_a2a_agent = None  # Initialized lazily in route handlers
+
         self.additional_routes = additional_routes if additional_routes is not None else []
         self.async_stream = async_stream
         self.add_langfuse_eval = add_langfuse_eval
@@ -177,6 +195,15 @@ if __name__ == "__main__":
         # MCP server endpoint
         if self.enable_mcp_server and self.vac_mcp_server:
             self.app.route('/mcp', methods=['POST', 'GET'])(self.handle_mcp_server)
+        
+        # A2A agent endpoints
+        if self.enable_a2a_agent:
+            self.app.route('/.well-known/agent.json', methods=['GET'])(self.handle_a2a_agent_card)
+            self.app.route('/a2a/tasks/send', methods=['POST'])(self.handle_a2a_task_send)
+            self.app.route('/a2a/tasks/sendSubscribe', methods=['POST'])(self.handle_a2a_task_send_subscribe)
+            self.app.route('/a2a/tasks/get', methods=['POST'])(self.handle_a2a_task_get)
+            self.app.route('/a2a/tasks/cancel', methods=['POST'])(self.handle_a2a_task_cancel)
+            self.app.route('/a2a/tasks/pushNotification/set', methods=['POST'])(self.handle_a2a_push_notification)
     
         self.register_additional_routes()
 
@@ -1037,11 +1064,8 @@ if __name__ == "__main__":
                     
                     try:
                         # Process the request through the server
-                        await server.run(
-                            read_messages(),
-                            write_queue,
-                            InitializationOptions() if InitializationOptions else None
-                        )
+                        # Use the server's run method with HTTP transport
+                        await server.run()
                     except Exception as e:
                         log.error(f"Error processing MCP request: {e}")
                         await write_queue.put(None)
@@ -1059,15 +1083,8 @@ if __name__ == "__main__":
                 loop = asyncio.new_event_loop()
                 asyncio.set_event_loop(loop)
                 try:
-                    responses = loop.run_until_complete(process_request())
-                    
-                    # Parse and return the response
-                    if responses:
-                        # The response should be a single JSON-RPC response
-                        response_data = json_module.loads(responses[0])
-                        return jsonify(response_data)
-                    else:
-                        return jsonify({"error": "No response from MCP server"}), 500
+                    response_data = loop.run_until_complete(process_request())
+                    return jsonify(response_data)
 
                 except Exception as e:
                     log.error(f"MCP server error: {str(e)}")
@@ -1101,4 +1118,224 @@ if __name__ == "__main__":
                 "transport": "http",
                 "endpoint": "/mcp",
                 "tools": ["vac_stream", "vac_query"] if self.vac_interpreter else ["vac_stream"]
-            })
+            })
+    
+    def _get_or_create_a2a_agent(self):
+        """Get or create the A2A agent instance with current request context."""
+        if not self.enable_a2a_agent or not VACA2AAgent:
+            return None
+        
+        if self.vac_a2a_agent is None:
+            # Extract base URL from current request
+            base_url = request.url_root.rstrip('/')
+            
+            self.vac_a2a_agent = VACA2AAgent(
+                base_url=base_url,
+                stream_interpreter=self.stream_interpreter,
+                vac_interpreter=self.vac_interpreter,
+                vac_names=self.a2a_vac_names
+            )
+        
+        return self.vac_a2a_agent
+    
+    def handle_a2a_agent_card(self):
+        """Handle A2A agent card discovery request."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        return jsonify(agent.get_agent_card())
+    
+    def handle_a2a_task_send(self):
+        """Handle A2A task send request."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON"
+                    },
+                    "id": None
+                }), 400
+            
+            # Run async handler
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                response = loop.run_until_complete(agent.handle_task_send(data))
+                return jsonify(response)
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            log.error(f"A2A task send error: {e}")
+            return jsonify({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                },
+                "id": data.get("id") if 'data' in locals() else None
+            }), 500
+    
+    def handle_a2a_task_send_subscribe(self):
+        """Handle A2A task send with subscription (SSE)."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                def error_generator():
+                    yield "data: {\"error\": \"Parse error: Invalid JSON\"}\n\n"
+                
+                return Response(error_generator(), content_type='text/event-stream')
+            
+            # Create async generator for SSE
+            async def sse_generator():
+                async for chunk in agent.handle_task_send_subscribe(data):
+                    yield chunk
+            
+            def sync_generator():
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    async_gen = sse_generator()
+                    while True:
+                        try:
+                            chunk = loop.run_until_complete(async_gen.__anext__())
+                            yield chunk
+                        except StopAsyncIteration:
+                            break
+                finally:
+                    loop.close()
+            
+            return Response(sync_generator(), content_type='text/event-stream')
+            
+        except Exception as e:
+            log.error(f"A2A task send subscribe error: {e}")
+            def error_generator(err):
+                yield f"data: {{\"error\": \"Internal error: {str(err)}\"}}\n\n"
+            
+            return Response(error_generator(e), content_type='text/event-stream')
+    
+    def handle_a2a_task_get(self):
+        """Handle A2A task get request."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON"
+                    },
+                    "id": None
+                }), 400
+            
+            # Run async handler
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                response = loop.run_until_complete(agent.handle_task_get(data))
+                return jsonify(response)
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            log.error(f"A2A task get error: {e}")
+            return jsonify({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                },
+                "id": data.get("id") if 'data' in locals() else None
+            }), 500
+    
+    def handle_a2a_task_cancel(self):
+        """Handle A2A task cancel request."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON"
+                    },
+                    "id": None
+                }), 400
+            
+            # Run async handler
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                response = loop.run_until_complete(agent.handle_task_cancel(data))
+                return jsonify(response)
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            log.error(f"A2A task cancel error: {e}")
+            return jsonify({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                },
+                "id": data.get("id") if 'data' in locals() else None
+            }), 500
+    
+    def handle_a2a_push_notification(self):
+        """Handle A2A push notification settings."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON"
+                    },
+                    "id": None
+                }), 400
+            
+            # Run async handler
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                response = loop.run_until_complete(agent.handle_push_notification_set(data))
+                return jsonify(response)
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            log.error(f"A2A push notification error: {e}")
+            return jsonify({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                },
+                "id": data.get("id") if 'data' in locals() else None
+            }), 500

sunholo/mcp/__init__.py

@@ -14,7 +14,16 @@
 
 """MCP (Model Context Protocol) integration for Sunholo."""
 
-from .mcp_manager import MCPClientManager
-from .vac_mcp_server import VACMCPServer
+try:
+    from .mcp_manager import MCPClientManager
+except ImportError as e:
+    print(f"Warning: MCPClientManager not available - {e}")
+    MCPClientManager = None
+
+try:
+    from .vac_mcp_server import VACMCPServer
+except ImportError as e:
+    print(f"Warning: VACMCPServer not available - {e}")
+    VACMCPServer = None
 
 __all__ = ['MCPClientManager', 'VACMCPServer']

sunholo/mcp/mcp_manager.py

@@ -4,11 +4,34 @@ This shows how to integrate MCP servers with your Flask/VACRoutes application.
 """
 
 from typing import Dict, Any, List, Optional
+import asyncio
 
-# Official MCP imports
-from mcp import StdioServerParameters, ClientSession
-from mcp.client.stdio import stdio_client
-from mcp.types import Tool, Resource, TextContent, CallToolResult
+# MCP SDK imports - try different import paths
+try:
+    from mcp.client.stdio import StdioClientTransport
+    from mcp.client.session import ClientSession
+except ImportError:
+    try:
+        # Alternative import paths
+        from mcp.client import StdioClientTransport, ClientSession
+    except ImportError:
+        try:
+            # Another alternative
+            from mcp import StdioClientTransport, ClientSession
+        except ImportError:
+            StdioClientTransport = None
+            ClientSession = None
+
+try:
+    from mcp.types import Tool, Resource, TextContent, CallToolResult
+except ImportError:
+    try:
+        from mcp import Tool, Resource, TextContent, CallToolResult
+    except ImportError:
+        Tool = None
+        Resource = None
+        TextContent = None
+        CallToolResult = None
 
 
 class MCPClientManager:
@@ -23,41 +46,42 @@ class MCPClientManager:
         if server_name in self.sessions:
             return self.sessions[server_name]
         
-        # Create server parameters
-        server_params = StdioServerParameters(
+        if not StdioClientTransport or not ClientSession:
+            raise ImportError("MCP client dependencies not available")
+        
+        # Create transport and session
+        transport = StdioClientTransport(
             command=command,
             args=args or []
         )
+        session = ClientSession(transport)
+        await session.initialize()
         
-        # Connect to the server
-        async with stdio_client(server_params) as (read, write):
-            # Create and initialize client session directly
-            session = ClientSession(read, write)
-            await session.initialize()
-            self.sessions[server_name] = session
-            self.server_configs[server_name] = {
-                "command": command,
-                "args": args
-            }
-            return session
+        self.sessions[server_name] = session
+        self.server_configs[server_name] = {
+            "command": command,
+            "args": args
+        }
+        return session
     
     async def list_tools(self, server_name: Optional[str] = None) -> List[Tool]:
         """List available tools from one or all connected servers."""
         if server_name:
             session = self.sessions.get(server_name)
             if session:
-                return await session.list_tools()
+                result = await session.list_tools()
+                return result.tools
             return []
         
         # List from all servers
         all_tools = []
         for name, session in self.sessions.items():
-            tools = await session.list_tools()
+            result = await session.list_tools()
             # Add server name to tool metadata
-            for tool in tools:
+            for tool in result.tools:
                 tool.metadata = tool.metadata or {}
                 tool.metadata["server"] = name
-            all_tools.extend(tools)
+            all_tools.extend(result.tools)
         return all_tools
     
     async def call_tool(self, server_name: str, tool_name: str, arguments: Dict[str, Any]) -> CallToolResult:
@@ -67,7 +91,13 @@ class MCPClientManager:
             raise ValueError(f"Not connected to server: {server_name}")
         
         # Call the tool
-        result = await session.call_tool(tool_name, arguments)
+        try:
+            from mcp.types import CallToolRequest
+            request = CallToolRequest(name=tool_name, arguments=arguments)
+            result = await session.call_tool(request)
+        except ImportError:
+            # Try direct call if Request types not available
+            result = await session.call_tool(tool_name, arguments)
         return result
     
     async def list_resources(self, server_name: Optional[str] = None) -> List[Resource]:
@@ -75,17 +105,18 @@ class MCPClientManager:
         if server_name:
             session = self.sessions.get(server_name)
             if session:
-                return await session.list_resources()
+                result = await session.list_resources()
+                return result.resources
             return []
         
         # List from all servers
         all_resources = []
         for name, session in self.sessions.items():
-            resources = await session.list_resources()
-            for resource in resources:
+            result = await session.list_resources()
+            for resource in result.resources:
                 resource.metadata = resource.metadata or {}
                 resource.metadata["server"] = name
-            all_resources.extend(resources)
+            all_resources.extend(result.resources)
         return all_resources
     
     async def read_resource(self, server_name: str, uri: str) -> List[TextContent]:
@@ -94,5 +125,12 @@ class MCPClientManager:
         if not session:
             raise ValueError(f"Not connected to server: {server_name}")
         
-        result = await session.read_resource(uri)
-        return result.contents
+        try:
+            from mcp.types import ReadResourceRequest
+            request = ReadResourceRequest(uri=uri)
+            result = await session.read_resource(request)
+        except ImportError:
+            # Try direct call if Request types not available
+            result = await session.read_resource(uri)
+        
+        return result.contents if hasattr(result, 'contents') else result

sunholo/mcp/vac_mcp_server.py

@@ -22,13 +22,8 @@ import json
 import asyncio
 from functools import partial
 
-try:
-    from mcp.server import Server
-    from mcp.types import Tool, TextContent, ImageContent, EmbeddedResource
-except ImportError:
-    Server = None
-    Tool = None
-    TextContent = None
+from mcp.server import Server
+from mcp.types import Tool, TextContent, ImageContent, EmbeddedResource
 
 from ..custom_logging import log
 from ..streaming import start_streaming_chat_async
@@ -45,8 +40,7 @@ class VACMCPServer:
             stream_interpreter: The streaming interpreter function
             vac_interpreter: The static VAC interpreter function (optional)
         """
-        if Server is None:
-            raise ImportError("MCP server requires `pip install sunholo[anthropic]`")
+        # MCP server is always available with current SDK
         
         self.stream_interpreter = stream_interpreter
         self.vac_interpreter = vac_interpreter

{sunholo-0.143.1.dist-info → sunholo-0.143.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.143.1
+Version: 0.143.7
 Summary: AI DevOps - a package to help deploy GenAI to the Cloud.
 Author-email: Holosun ApS <multivac@sunholo.com>
 License: Apache License, Version 2.0
@@ -15,9 +15,10 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: a2a-python>=0.0.1
 Requires-Dist: aiohttp
 Requires-Dist: flask>=3.1.0
 Requires-Dist: google-auth
@@ -126,6 +127,7 @@ Requires-Dist: pytesseract; extra == "pipeline"
 Requires-Dist: tabulate; extra == "pipeline"
 Requires-Dist: unstructured[all-docs,local-inference]; extra == "pipeline"
 Provides-Extra: gcp
+Requires-Dist: a2a-python; extra == "gcp"
 Requires-Dist: aiofiles; extra == "gcp"
 Requires-Dist: anthropic[vertex]; extra == "gcp"
 Requires-Dist: google-api-python-client; extra == "gcp"

{sunholo-0.143.1.dist-info → sunholo-0.143.7.dist-info}/RECORD

@@ -1,6 +1,10 @@
-sunholo/__init__.py,sha256=InRbX4V0-qdNHo9zYH3GEye7ASLR6LX8-SMvPV4Jsaw,1212
+sunholo/__init__.py,sha256=_zHD01JyUVc-kGqm_bWtWxytec3b8-25fm5vK5j_2VU,1256
 sunholo/custom_logging.py,sha256=JXZTnXp_DixP3jwYfKw4LYRDS9IuTq7ctCgfZbI2rxA,22023
 sunholo/langchain_types.py,sha256=uZ4zvgej_f7pLqjtu4YP7qMC_eZD5ym_5x4pyvA1Ih4,1834
+sunholo/a2a/__init__.py,sha256=ohwR-3_toRUdyj3ACNCVPrd_V2lzR5tmL5Hwn1ChSSU,1049
+sunholo/a2a/agent_card.py,sha256=TJOgZ5FZJGgapyFXzBIRnnocUWcfSLah7fjvl0fLYJ4,13387
+sunholo/a2a/task_manager.py,sha256=Ox1oAHarqYdcWku_JFcYDt2pQG3gwfuBTO7WCakE-U0,17670
+sunholo/a2a/vac_a2a_agent.py,sha256=vL-sQceVRBE9d3kjx9m8zGWK1S9J1sHUybAH3tSbVFg,13344
 sunholo/agents/__init__.py,sha256=AauG3l0y4r5Fzx1zJfZ634M4o-0o7B7J5T8k_gPvNqE,370
 sunholo/agents/chat_history.py,sha256=gRuIUyU-53A72Q17SmSgf6Ok3YO8hKAZhsc64976018,17782
 sunholo/agents/dispatch_to_qa.py,sha256=NHihwAoCJ5_Lk11e_jZnucVUGQyZHCB-YpkfMHBCpQk,8882
@@ -14,7 +18,7 @@ sunholo/agents/fastapi/base.py,sha256=W-cyF8ZDUH40rc-c-Apw3-_8IIi2e4Y9qRtnoVnsc1
 sunholo/agents/fastapi/qna_routes.py,sha256=lKHkXPmwltu9EH3RMwmD153-J6pE7kWQ4BhBlV3to-s,3864
 sunholo/agents/flask/__init__.py,sha256=dEoByI3gDNUOjpX1uVKP7uPjhfFHJubbiaAv3xLopnk,63
 sunholo/agents/flask/base.py,sha256=vnpxFEOnCmt9humqj-jYPLfJcdwzsop9NorgkJ-tSaU,1756
-sunholo/agents/flask/vac_routes.py,sha256=P_swGAAEee2Z9BdOTQEFza9aI78ezCVtF1MNNi67pug,44599
+sunholo/agents/flask/vac_routes.py,sha256=MvEsIWxrdeuRx-t_RfkodnJyJKP40aKaADWV4Yi3ijw,53375
 sunholo/archive/__init__.py,sha256=qNHWm5rGPVOlxZBZCpA1wTYPbalizRT7f8X4rs2t290,31
 sunholo/archive/archive.py,sha256=PxVfDtO2_2ZEEbnhXSCbXLdeoHoQVImo4y3Jr2XkCFY,1204
 sunholo/auth/__init__.py,sha256=TeP-OY0XGxYV_8AQcVGoh35bvyWhNUcMRfhuD5l44Sk,91
@@ -110,10 +114,10 @@ sunholo/llamaindex/llamaindex_class.py,sha256=PnpPoc7LpP7xvKIXYu-UvI4ehj67pGhE1E
 sunholo/llamaindex/user_history.py,sha256=ZtkecWuF9ORduyGB8kF8gP66bm9DdvCI-ZiK6Kt-cSE,2265
 sunholo/lookup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/lookup/model_lookup.yaml,sha256=O7o-jP53MLA06C8pI-ILwERShO-xf6z_258wtpZBv6A,739
-sunholo/mcp/__init__.py,sha256=GmKB8Z0ecXUzpuzYEOXSI0aaZP7LZJc7yTCMEFdAmi4,791
+sunholo/mcp/__init__.py,sha256=Bi0ZYMvWuf1AL_QSrMAREVVdTZFiIokGwrytBXKBJyc,1028
 sunholo/mcp/cli.py,sha256=d24nnVzhZYz4AWgTqmN-qjKG4rPbf8RhdmEOHZkBHy8,10570
-sunholo/mcp/mcp_manager.py,sha256=ooa_2JSNaKIuK9azEV0OaPVf5Mp_tL_DHaYEyFCmgKY,3752
-sunholo/mcp/vac_mcp_server.py,sha256=fRcerTqp_pTK8AVITpGPhrez_IaDuUDr4WnVUHPv8GM,10114
+sunholo/mcp/mcp_manager.py,sha256=g75vv6XvM24U7uz366slE-p76Qs4AvVcsarHSF9qIvE,5061
+sunholo/mcp/vac_mcp_server.py,sha256=DSSMsTeLU_1C2hHTvgLjZsg1chyMfb_S9ruCUw2f_dc,9969
 sunholo/ollama/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/ollama/ollama_images.py,sha256=H2cpcNu88R4TwyfL_nnqkQhdvBQ2FPCAy4Ok__0yQmo,2351
 sunholo/pubsub/__init__.py,sha256=DfTEk4zmCfqn6gFxRrqDO0pOrvXTDqH-medpgYO4PGw,117
@@ -171,9 +175,9 @@ sunholo/vertex/init.py,sha256=1OQwcPBKZYBTDPdyU7IM4X4OmiXLdsNV30C-fee2scQ,2875
 sunholo/vertex/memory_tools.py,sha256=tBZxqVZ4InTmdBvLlOYwoSEWu4-kGquc-gxDwZCC4FA,7667
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
 sunholo/vertex/type_dict_to_json.py,sha256=uTzL4o9tJRao4u-gJOFcACgWGkBOtqACmb6ihvCErL8,4694
-sunholo-0.143.1.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.143.1.dist-info/METADATA,sha256=bvNatmW9CaH2Fyn2AN8np1IeiLF0MNciSg7gjihkYvI,18338
-sunholo-0.143.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sunholo-0.143.1.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.143.1.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.143.1.dist-info/RECORD,,
+sunholo-0.143.7.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.143.7.dist-info/METADATA,sha256=c1IhnVsC3r20UUvBImOmvOIirVrkuNY6Tj-xFuF3jr0,18413
+sunholo-0.143.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sunholo-0.143.7.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.143.7.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.143.7.dist-info/RECORD,,