open-edison 0.1.44__py3-none-any.whl → 0.1.72rc1__py3-none-any.whl

src/single_user_mcp.py

@@ -5,11 +5,21 @@ FastMCP instance for the single-user Open Edison setup.
 Handles MCP protocol communication with running servers using a unified composite proxy.
 """
 
+import asyncio
+import time
 from typing import Any, TypedDict
 
 from fastmcp import Client as FastMCPClient
 from fastmcp import Context, FastMCP
+from fastmcp.server.server import add_resource_prefix, has_resource_prefix
+
+# Low level FastMCP imports
+from fastmcp.tools.tool import Tool
+from fastmcp.tools.tool_transform import (
+    apply_transformations_to_tools,
+)
 from loguru import logger as log
+from mcp.server.lowlevel.server import LifespanResultT
 
 from src.config import Config, MCPServerConfig
 from src.middleware.session_tracking import (
@@ -60,6 +70,114 @@ class SingleUserMCP(FastMCP[Any]):
         self._setup_demo_resources()
         self._setup_demo_prompts()
 
+    async def import_server(
+        self,
+        server: FastMCP[LifespanResultT],
+        prefix: str | None = None,
+        tool_separator: str | None = None,
+        resource_separator: str | None = None,
+        prompt_separator: str | None = None,
+    ) -> None:
+        """
+        Import the MCP objects from another FastMCP server into this one with a given prefix.
+        Overloads FastMCP's import_server method to improve performance.
+
+        Args:
+            server: The FastMCP server to import
+            prefix: prefix to use for the imported server's objects. If None,
+                objects are imported with their original names.
+            tool_separator: Deprecated. Required to be None.
+            resource_separator: Deprecated. Required to be None.
+            prompt_separator: Deprecated. Required to be None.
+        """
+
+        if prefix is None:
+            raise ValueError("Prefix is required")
+
+        if tool_separator is not None:
+            raise ValueError("Tool separator is deprecated and not supported")
+
+        if resource_separator is not None:
+            raise ValueError("Resource separator is deprecated and not supported")
+
+        if prompt_separator is not None:
+            raise ValueError("Prompt separator is deprecated and not supported")
+
+        log.debug(f"🔧 Importing server {prefix} ({server.name}) into single user MCP'")
+
+        # Fetch all server objects in parallel
+        tools, resources, templates, prompts = await asyncio.gather(
+            server.get_tools(),
+            server.get_resources(),
+            server.get_resource_templates(),
+            server.get_prompts(),
+            return_exceptions=True,
+        )
+
+        # Validate and normalize all results
+        tools = self._validate_server_result(tools, "tools", server.name)
+        resources = self._validate_server_result(resources, "resources", server.name)
+        templates = self._validate_server_result(templates, "templates", server.name)
+        prompts = self._validate_server_result(prompts, "prompts", server.name)
+
+        # Import all components
+        self._import_tools(tools, prefix)
+        self._import_resources(resources, prefix)
+        self._import_templates(templates, prefix)
+        self._import_prompts(prompts, prefix)
+
+        log.debug(f"Imported server {server.name} with prefix '{prefix}'")
+
+    def _validate_server_result(
+        self, result: Any, result_type: str, server_name: str
+    ) -> dict[str, Any]:
+        """Validate and normalize server result from asyncio.gather with return_exceptions=True."""
+        if isinstance(result, Exception):
+            log.warning(f'Server {server_name} does not appear to contain "{result_type}"')
+            log.debug(f"Server {server_name} _validate_server_result exception result: {result}")
+            return {}
+        if not isinstance(result, dict):
+            log.warning(f"Server {server_name} returned an unexpected response")
+            log.debug(
+                f"Server {server_name} _validate_server_result unexpected type {type(result)} with value: {result}"
+            )
+            return {}
+        return result  # type: ignore[return-value]
+
+    def _import_tools(self, tools: dict[str, Any], prefix: str) -> None:
+        """Import tools from server"""
+        for key, tool in tools.items():
+            if prefix:
+                tool = tool.model_copy(key=f"{prefix}_{key}")
+            self._tool_manager.add_tool(tool)
+
+    def _import_resources(self, resources: dict[str, Any], prefix: str) -> None:
+        """Import resources from server"""
+        for key, resource in resources.items():
+            if prefix:
+                resource_key = add_resource_prefix(key, prefix, self.resource_prefix_format)
+                resource = resource.model_copy(
+                    update={"name": f"{prefix}_{resource.name}"}, key=resource_key
+                )
+            self._resource_manager.add_resource(resource)
+
+    def _import_templates(self, templates: dict[str, Any], prefix: str) -> None:
+        """Import templates from server"""
+        for key, template in templates.items():
+            if prefix:
+                template_key = add_resource_prefix(key, prefix, self.resource_prefix_format)
+                template = template.model_copy(
+                    update={"name": f"{prefix}_{template.name}"}, key=template_key
+                )
+            self._resource_manager.add_template(template)
+
+    def _import_prompts(self, prompts: dict[str, Any], prefix: str) -> None:
+        """Import prompts from server"""
+        for key, prompt in prompts.items():
+            if prefix:
+                prompt = prompt.model_copy(key=f"{prefix}_{key}")
+            self._prompt_manager.add_prompt(prompt)
+
     def _convert_to_fastmcp_config(self, enabled_servers: list[MCPServerConfig]) -> dict[str, Any]:
         """
         Convert Open Edison config format to FastMCP MCPConfig format.
@@ -87,46 +205,6 @@ class SingleUserMCP(FastMCP[Any]):
 
         return {"mcpServers": mcp_servers}
 
-    async def create_composite_proxy(self, enabled_servers: list[MCPServerConfig]) -> bool:
-        """
-        Create a unified composite proxy for all enabled MCP servers.
-
-        This replaces individual server mounting with a single FastMCP composite proxy
-        that handles all configured servers with automatic namespacing.
-
-        Args:
-            enabled_servers: List of enabled MCP server configurations
-
-        Returns:
-            True if composite proxy was created successfully, False otherwise
-        """
-        if not enabled_servers:
-            log.info("No real servers to mount in composite proxy")
-            return True
-
-        oauth_manager = get_oauth_manager()
-
-        for server_config in enabled_servers:
-            server_name = server_config.name
-
-            # Skip if this server would produce an empty config (e.g., misconfigured)
-            fastmcp_config = self._convert_to_fastmcp_config([server_config])
-            if not fastmcp_config.get("mcpServers"):
-                log.warning(f"Skipping server '{server_name}' due to empty MCP config")
-                continue
-
-            try:
-                await self._mount_single_server(server_config, fastmcp_config, oauth_manager)
-            except Exception as e:
-                log.error(f"❌ Failed to mount server {server_name}: {e}")
-                # Continue with other servers even if one fails
-                continue
-
-        log.info(
-            f"✅ Created composite proxy with {len(enabled_servers)} servers ({mounted_servers.keys()})"
-        )
-        return True
-
     async def _mount_single_server(
         self,
         server_config: MCPServerConfig,
@@ -140,6 +218,7 @@ class SingleUserMCP(FastMCP[Any]):
         remote_url = server_config.get_remote_url()
         oauth_info = await oauth_manager.check_oauth_requirement(server_name, remote_url)
 
+        client_timeout = 10
         # Create proxy based on server type to avoid union type issues
         if server_config.is_remote_server():
             # Handle remote servers (with or without OAuth)
@@ -156,18 +235,22 @@ class SingleUserMCP(FastMCP[Any]):
                     server_config.oauth_client_name,
                 )
                 if oauth_auth:
-                    client = FastMCPClient(remote_url, auth=oauth_auth)
+                    client = FastMCPClient(
+                        remote_url,
+                        auth=oauth_auth,
+                        timeout=client_timeout,
+                    )
                     log.info(
                         f"🔐 Created remote client with OAuth authentication for {server_name}"
                     )
                 else:
-                    client = FastMCPClient(remote_url)
+                    client = FastMCPClient(remote_url, timeout=client_timeout)
                     log.warning(
                         f"⚠️ OAuth auth creation failed, using unauthenticated client for {server_name}"
                     )
             else:
                 # Remote server without OAuth or needs auth
-                client = FastMCPClient(remote_url)
+                client = FastMCPClient(remote_url, timeout=client_timeout)
                 log.info(f"🌐 Created remote client for {server_name}")
 
             # Log OAuth status warnings
@@ -184,10 +267,12 @@ class SingleUserMCP(FastMCP[Any]):
 
         else:
             # Local server - create proxy directly from config (avoids union type issue)
-            log.info(f"🔧 Creating local process proxy for {server_name}")
+            log.debug(f"🔧 Creating local process proxy for {server_name}")
             proxy = FastMCP.as_proxy(fastmcp_config)
 
-        super().mount(proxy, prefix=server_name)
+        log.debug(f"🔧 Importing server {server_name} into single user MCP")
+        await self.import_server(proxy, prefix=server_name)
+        # await super().import_server(proxy, prefix=server_name)
         mounted_servers[server_name] = MountedServerInfo(config=server_config, proxy=proxy)
 
         server_type = "remote" if server_config.is_remote_server() else "local"
@@ -230,10 +315,7 @@ class SingleUserMCP(FastMCP[Any]):
         try:
             oauth_manager = get_oauth_manager()
             await self._mount_single_server(server_config, fastmcp_config, oauth_manager)
-            # Warm lists after mount
-            _ = await self._tool_manager.list_tools()
-            _ = await self._resource_manager.list_resources()
-            _ = await self._prompt_manager.list_prompts()
+
             return True
         except Exception as e:  # noqa: BLE001
             log.error(f"❌ Failed to mount server {server_name}: {e}")
@@ -242,7 +324,6 @@ class SingleUserMCP(FastMCP[Any]):
     async def unmount(self, server_name: str) -> bool:
         """
         Unmount a previously mounted server by name.
-
         Returns True if it was unmounted, False if it wasn't mounted.
         """
         info = mounted_servers.pop(server_name, None)
@@ -250,85 +331,145 @@ class SingleUserMCP(FastMCP[Any]):
             log.info(f"ℹ️  Server {server_name} was not mounted")
             return False
 
-        proxy = info.get("proxy")
-
-        # Manually remove from FastMCP managers' mounted lists
+        # Remove the server from mounted_servers lists in all managers
         for manager_name in ("_tool_manager", "_resource_manager", "_prompt_manager"):
             manager = getattr(self, manager_name, None)
+            if manager is None:
+                continue
             mounted_list = getattr(manager, "_mounted_servers", None)
             if mounted_list is None:
                 continue
 
-            # Prefer removing by both prefix and object identity; fallback to prefix-only
-            new_list = [
-                m
-                for m in mounted_list
-                if not (m.prefix == server_name and (proxy is None or m.server is proxy))
-            ]
-            if len(new_list) == len(mounted_list):
-                new_list = [m for m in mounted_list if m.prefix != server_name]
+            # Remove servers with matching prefix
+            mounted_list[:] = [m for m in mounted_list if m.prefix != server_name]
 
-            mounted_list[:] = new_list
+        # Remove tools with matching prefix (server name)
+        self._tool_manager._tools = {  # type: ignore
+            key: value
+            for key, value in self._tool_manager._tools.items()  # type: ignore
+            if not key.startswith(f"{server_name}_")
+        }
 
-        # Invalidate and warm lists to ensure reload
-        _ = await self._tool_manager.list_tools()
-        _ = await self._resource_manager.list_resources()
-        _ = await self._prompt_manager.list_prompts()
+        # Remove transformations with matching prefix (server name)
+        self._tool_manager.transformations = {  # type: ignore
+            key: value
+            for key, value in self._tool_manager.transformations.items()  # type: ignore
+            if not key.startswith(f"{server_name}_")
+        }
+
+        # Remove resources with matching prefix (server name)
+        self._resource_manager._resources = {  # type: ignore
+            key: value
+            for key, value in self._resource_manager._resources.items()  # type: ignore
+            if not has_resource_prefix(key, server_name, self.resource_prefix_format)  # type: ignore
+        }
+
+        # Remove templates with matching prefix (server name)
+        self._resource_manager._templates = {  # type: ignore
+            key: value
+            for key, value in self._resource_manager._templates.items()  # type: ignore
+            if not has_resource_prefix(key, server_name, self.resource_prefix_format)  # type: ignore
+        }
+
+        # Remove prompts with matching prefix (server name)
+        self._prompt_manager._prompts = {  # type: ignore
+            key: value
+            for key, value in self._prompt_manager._prompts.items()  # type: ignore
+            if not key.startswith(f"{server_name}_")
+        }
 
         log.info(f"🧹 Unmounted server {server_name} and cleared references")
         return True
 
-    async def _send_list_changed_notifications(self) -> None:
-        """Send notifications to clients about changed component lists."""
-        try:
-            # Import here to avoid circular imports
-            from fastmcp.server.dependencies import get_context
-
-            try:
-                context = get_context()
-                # Queue notifications for all component types since we don't know
-                # what types of components the unmounted server provided
-                context._queue_tool_list_changed()  # type: ignore
-                context._queue_resource_list_changed()  # type: ignore
-                context._queue_prompt_list_changed()  # type: ignore
-                log.debug("Queued component list change notifications")
-            except RuntimeError:
-                # No active context - notifications will be sent when context becomes available
-                log.debug("No active context for notifications")
-
-        except Exception as e:
-            log.warning(f"Error sending unmount notifications: {e}")
+    async def list_all_servers_tools_parallel(self) -> list[Tool]:
+        """Reload all servers' tools in parallel.
+        Reimplements FastMCP's ToolManager._list_tools method with parallel execution.
+        """
+
+        # Execute all server reloads in parallel
+        list_tasks = [
+            server.server._list_tools()
+            for server in self._tool_manager._mounted_servers  # type: ignore
+        ]
+
+        log.debug(f"Starting reload for {len(list_tasks)} servers' tools in parallel")
+        start_time = time.perf_counter()
+        all_tools: dict[str, Tool] = {}
+        if list_tasks:
+            # Use return_exceptions=True to prevent one failing server from breaking everything
+            tools_lists = await asyncio.gather(*list_tasks, return_exceptions=True)
+            for server, tools_result in zip(
+                self._tool_manager._mounted_servers,  # type: ignore
+                tools_lists,
+                strict=False,
+            ):
+                if isinstance(tools_result, Exception):
+                    log.warning(f"Failed to get tools from server {server.prefix}: {tools_result}")
+                    continue
+
+                tools_list = tools_result
+                if not tools_list or not isinstance(tools_list, list):
+                    continue
+
+                tools_dict = {t.key: t for t in tools_list}  # type: ignore
+                if server.prefix:
+                    for tool in tools_dict.values():
+                        prefixed_tool = tool.model_copy(  # type: ignore
+                            key=f"{server.prefix}_{tool.key}"  # type: ignore
+                        )
+                        all_tools[prefixed_tool.key] = prefixed_tool  # type: ignore
+                else:
+                    all_tools.update(tools_dict)  # type: ignore
+            log.debug(
+                f"Saved {len(all_tools)} tools from {len([r for r in tools_lists if not isinstance(r, Exception)])} servers"
+            )
+        else:
+            all_tools = {}
+
+        # Add local tools
+        all_tools.update(self._tool_manager._tools)  # type: ignore
+
+        transformed_tools = apply_transformations_to_tools(
+            tools=all_tools,
+            transformations=self._tool_manager.transformations,
+        )
+
+        final_tools_list = list(transformed_tools.values())
+
+        end_time = time.perf_counter()
+        log.debug(f"Time taken to reload all servers' tools: {end_time - start_time:.1f} seconds")
+        return final_tools_list
 
     async def initialize(self) -> None:
         """Initialize the FastMCP server using unified composite proxy approach."""
         log.info("Initializing Single User MCP server with composite proxy")
         log.debug(f"Available MCP servers in config: {[s.name for s in Config().mcp_servers]}")
-
+        start_time = time.perf_counter()
         # Get all enabled servers
         enabled_servers = [s for s in Config().mcp_servers if s.enabled]
         log.info(
             f"Found {len(enabled_servers)} enabled servers: {[s.name for s in enabled_servers]}"
         )
 
-        # Unmount all servers
-        for server_name in list(mounted_servers.keys()):
-            await self.unmount(server_name)
+        # Figure out which servers are to be unmounted
+        enabled_server_names = {s.name for s in enabled_servers}
+        servers_to_unmount = [s for s in mounted_servers if s not in enabled_server_names]
 
-        # Create composite proxy for all real servers
-        success = await self.create_composite_proxy(enabled_servers)
-        if not success:
-            log.error("Failed to create composite proxy")
-            return
+        # Figure out which servers are to be mounted
+        servers_to_mount = [s.name for s in enabled_servers if s.name not in mounted_servers]
 
-        log.info("✅ Single User MCP server initialized with composite proxy")
+        # Unmount those servers (quick)
+        for server_name in servers_to_unmount:
+            await self.unmount(server_name)
 
-        # Invalidate and warm lists to ensure reload
-        _ = await self._tool_manager.list_tools()
-        _ = await self._resource_manager.list_resources()
-        _ = await self._prompt_manager.list_prompts()
+        # Mount those servers (async gathered bc import does network roundtrip)
+        mount_tasks = [self.mount_server(server_name) for server_name in servers_to_mount]
+        await asyncio.gather(*mount_tasks)
 
-        # Send notifications to clients about changed component lists
-        await self._send_list_changed_notifications()
+        log.info("✅ Single User MCP server initialized with composite proxy")
+        log.debug(
+            f"Time taken to initialize Single User MCP server: {time.perf_counter() - start_time:.1f} seconds"
+        )
 
     def _calculate_risk_level(self, trifecta: dict[str, bool]) -> str:
         """
@@ -418,7 +559,7 @@ class SingleUserMCP(FastMCP[Any]):
             """
             Get a list of all available tools. Use this tool to get an updated list of available tools.
             """
-            tool_list = await self._tool_manager.list_tools()
+            tool_list = await self.list_all_servers_tools_parallel()
             available_tools: list[str] = []
             log.trace(f"Raw tool list: {tool_list}")
             perms = Permissions()
@@ -454,7 +595,7 @@ class SingleUserMCP(FastMCP[Any]):
     def _setup_demo_resources(self) -> None:
         """Set up built-in demo resources for testing."""
 
-        @self.resource("config://app")  # noqa
+        @self.resource("info://builtin/app")  # noqa
         def builtin_get_app_config() -> dict[str, Any]:
             """Get application configuration."""
             return {
@@ -463,7 +604,7 @@ class SingleUserMCP(FastMCP[Any]):
                 "total_mounted": len(mounted_servers),
             }
 
-        log.info("✅ Added built-in demo resources: config://app")
+        log.info("✅ Added built-in demo resources: info://builtin/app")
 
     def _setup_demo_prompts(self) -> None:
         """Set up built-in demo prompts for testing."""

src/tools/io.py

@@ -0,0 +1,35 @@
+import os
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+
+@contextmanager
+def suppress_fds(*, suppress_stdout: bool = False, suppress_stderr: bool = True) -> Iterator[None]:
+    """Temporarily redirect process-level stdout/stderr to os.devnull.
+
+    Args:
+        suppress_stdout: If True, redirect fd 1 to devnull
+        suppress_stderr: If True, redirect fd 2 to devnull
+
+    Yields:
+        None
+    """
+    saved: list[tuple[int, int]] = []
+    try:
+        if suppress_stdout:
+            saved.append((1, os.dup(1)))
+            devnull_out = os.open(os.devnull, os.O_WRONLY)
+            os.dup2(devnull_out, 1)
+            os.close(devnull_out)
+        if suppress_stderr:
+            saved.append((2, os.dup(2)))
+            devnull_err = os.open(os.devnull, os.O_WRONLY)
+            os.dup2(devnull_err, 2)
+            os.close(devnull_err)
+        yield
+    finally:
+        for fd, backup in saved:
+            try:
+                os.dup2(backup, fd)
+            finally:
+                os.close(backup)

src/vulture_whitelist.py

@@ -0,0 +1,3 @@
+from src.oauth_override import OpenEdisonOAuth
+
+OpenEdisonOAuth.redirect_handler  # noqa: B018 unused method (src/oauth_override.py:7)

open_edison-0.1.44.dist-info/RECORD

@@ -1,37 +0,0 @@
-src/__init__.py,sha256=bEYMwBiuW9jzF07iWhas4Vb30EcpnqfpNfz_Q6yO1jU,209
-src/__main__.py,sha256=kQsaVyzRa_ESC57JpKDSQJAHExuXme0rM5beJsYxFeA,161
-src/cli.py,sha256=fqX-HuRDePRasexpnURQ_pVYeycJuWxllMcwfqDxMQw,8490
-src/config.py,sha256=RSsAYzl8cj6eaDN1RORMcfKKWBcp4bKTQp2BdhAL9mg,10258
-src/config.pyi,sha256=FgehEGli8ZXSjGlANBgMGv5497q4XskQciOc1fUcxqM,2033
-src/events.py,sha256=aFQrVXDIZwt55Dz6OtyoXu2yi9evqo-8jZzo3CR2Tto,4965
-src/oauth_manager.py,sha256=W9QSo0vfGDQ_i-QWCngkv7YLSL3Rk5jfPmqjU1J2rnU,9911
-src/permissions.py,sha256=NGAnlG_z59HEiVA-k3cYvwmmiuHzxuNb5Tbd5umbL00,10483
-src/server.py,sha256=cnO5bgxT-lrfuwk9AIvB_HBV8SWOtFClfGUn5_zFWyo,45652
-src/single_user_mcp.py,sha256=rJrlqHcIubGkos_24ux5rb3OoKYDzvagCHghhfDeXTI,18535
-src/telemetry.py,sha256=-RZPIjpI53zbsKmp-63REeZ1JirWHV5WvpSRa2nqZEk,11321
-src/frontend_dist/index.html,sha256=s95FMkH8VLisvawLH7bZxbLzRUFvMhHkH6ZMzpVBngs,673
-src/frontend_dist/sw.js,sha256=rihX1es-vWwjmtnXyaksJjs2dio6MVAOTAWwQPeJUYw,2164
-src/frontend_dist/assets/index-BUUcUfTt.js,sha256=awoyPI6u0v6ao2iarZdSkrSDUvyU8aNkMLqHMvgVgyY,257666
-src/frontend_dist/assets/index-o6_8mdM8.css,sha256=nwmX_6q55mB9463XN2JM8BdeihjkALpQK83Fc3_iGvE,15936
-src/mcp_importer/__init__.py,sha256=Mk59pVr7OMGfYGWeSYk8-URfhIcrs3SPLYS7fmJbMII,275
-src/mcp_importer/__main__.py,sha256=0jVfxKzyr6koVu1ghhWseah5ilKIoGovE6zkEZ-u-Og,515
-src/mcp_importer/api.py,sha256=47tur0xgl1NBI1Vnh3cpScEmDS64bKMYcWjZDuqx7HQ,6644
-src/mcp_importer/cli.py,sha256=Pe0GLWm1nMd1VuNXOSkxIrFZuGNFc9dNvfBsvf-bdBI,3487
-src/mcp_importer/export_cli.py,sha256=daEadB6nL8P4OpEGFx0GshuN1a091L7BhiitpV1bPqA,6294
-src/mcp_importer/exporters.py,sha256=fSgl6seduoXFp7YnKH26UEaC1sFBnd4whSut7CJLBQs,11348
-src/mcp_importer/import_api.py,sha256=xWaKoE3vibSWpA5roVL7qEMS73vcmAC0tcHP6CsZw6E,95
-src/mcp_importer/importers.py,sha256=zGN8lT7qQJ95jDTd-ck09j_w5PSvH-uj33TILoHfHbs,2191
-src/mcp_importer/merge.py,sha256=KIGT7UgbAm07-LdyoUXEJ7ABSIiPTFlj_qjz669yFxg,1569
-src/mcp_importer/parsers.py,sha256=JRE7y_Gg-QmlAARvZdrI9CmUyy-ODvDPbS695pb3Aw8,4856
-src/mcp_importer/paths.py,sha256=4L-cPr7KCM9X9gAUP7Da6ictLNrPWuQ_IM419zqY-2I,2700
-src/mcp_importer/quick_cli.py,sha256=4mJe10q_lZCYLm75QBt1rYy2j8mGEsRZoAqA0agjfSM,1834
-src/mcp_importer/types.py,sha256=h03TbAnJbap6OWWd0dT0QcFWNvSaiVFWH9V9PD6x4s0,138
-src/middleware/data_access_tracker.py,sha256=bArBffWgYmvxOx9z_pgXQhogvnWQcc1m6WvEblDD4gw,15039
-src/middleware/session_tracking.py,sha256=5W1VH9HNqIZeX0HNxDEm41U4GY6SqKSXtApDEeZK2qo,23084
-src/setup_tui/__init__.py,sha256=mDFrQoiOtQOHc0sFfGKrNXVLEDeB1S0O5aISBVzfxYo,184
-src/setup_tui/main.py,sha256=892X2KVKOYmKzUu1Ok8SnApNYxpcFHFHmFLvpPZP4qY,5501
-open_edison-0.1.44.dist-info/METADATA,sha256=hY2fd8IeT-YeBAUjg_FBtpGf50VGOpgRp4xdBhx7ED4,12375
-open_edison-0.1.44.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_edison-0.1.44.dist-info/entry_points.txt,sha256=YiGNm9x2I00hgT10HDyB4gxC1LcaV_mu8bXFjolu0Yw,171
-open_edison-0.1.44.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-open_edison-0.1.44.dist-info/RECORD,,