open-edison 0.1.17__py3-none-any.whl → 0.1.26__py3-none-any.whl

src/single_user_mcp.py

@@ -7,20 +7,23 @@ Handles MCP protocol communication with running servers using a unified composit
 
 from typing import Any, TypedDict
 
-from fastmcp import FastMCP
+from fastmcp import Client as FastMCPClient
+from fastmcp import Context, FastMCP
 from loguru import logger as log
 
-from src.config import MCPServerConfig, config
+from src.config import Config, MCPServerConfig
 from src.middleware.session_tracking import (
     SessionTrackingMiddleware,
     get_current_session_data_tracker,
 )
+from src.oauth_manager import OAuthManager, OAuthStatus, get_oauth_manager
+from src.permissions import Permissions, PermissionsError
 
 
 class MountedServerInfo(TypedDict):
     """Type definition for mounted server information."""
 
-    config: MCPServerConfig
+    config: MCPServerConfig  # noqa
     proxy: FastMCP[Any] | None
 
 
@@ -28,10 +31,14 @@ class ServerStatusInfo(TypedDict):
     """Type definition for server status information."""
 
     name: str
-    config: dict[str, str | list[str] | bool | dict[str, str] | None]
+    config: dict[str, str | list[str] | bool | dict[str, str] | None]  # noqa
     mounted: bool
 
 
+# Module level because needs to be read by permissions etc
+mounted_servers: dict[str, MountedServerInfo] = {}
+
+
 class SingleUserMCP(FastMCP[Any]):
     """
     Single-user MCP server implementation for Open Edison.
@@ -43,8 +50,6 @@ class SingleUserMCP(FastMCP[Any]):
 
     def __init__(self):
         super().__init__(name="open-edison-single-user")
-        self.mounted_servers: dict[str, MountedServerInfo] = {}
-        self.composite_proxy: FastMCP[Any] | None = None
 
         # Add session tracking middleware for data access monitoring
         self.add_middleware(SessionTrackingMiddleware())
@@ -67,10 +72,6 @@ class SingleUserMCP(FastMCP[Any]):
         mcp_servers: dict[str, dict[str, Any]] = {}
 
         for server_config in enabled_servers:
-            # Skip test servers for composite proxy
-            if server_config.command == "echo":
-                continue
-
             server_entry: dict[str, Any] = {
                 "command": server_config.command,
                 "args": server_config.args,
@@ -85,15 +86,6 @@ class SingleUserMCP(FastMCP[Any]):
 
         return {"mcpServers": mcp_servers}
 
-    async def _mount_test_server(self, server_config: MCPServerConfig) -> bool:
-        """Mount a test server with mock configuration."""
-        log.info(f"Mock mounting test server: {server_config.name}")
-        self.mounted_servers[server_config.name] = MountedServerInfo(
-            config=server_config, proxy=None
-        )
-        log.info(f"✅ Mounted test server: {server_config.name}")
-        return True
-
     async def create_composite_proxy(self, enabled_servers: list[MCPServerConfig]) -> bool:
         """
         Create a unified composite proxy for all enabled MCP servers.
@@ -107,161 +99,195 @@ class SingleUserMCP(FastMCP[Any]):
         Returns:
             True if composite proxy was created successfully, False otherwise
         """
-        try:
-            if not enabled_servers:
-                log.info("No real servers to mount in composite proxy")
-                return True
+        if not enabled_servers:
+            log.info("No real servers to mount in composite proxy")
+            return True
 
-            # Convert to FastMCP config format
-            fastmcp_config = self._convert_to_fastmcp_config(enabled_servers)
+        oauth_manager = get_oauth_manager()
 
-            log.info(
-                f"Creating composite proxy for servers: {list(fastmcp_config['mcpServers'].keys())}"
-            )
+        for server_config in enabled_servers:
+            server_name = server_config.name
 
-            # Create the composite proxy using FastMCP's multi-server support
-            self.composite_proxy = FastMCP.as_proxy(
-                backend=fastmcp_config, name="open-edison-composite-proxy"
-            )
+            # 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
 
-            # Import the composite proxy into this main server
-            # Tools and resources will be automatically namespaced by server name
-            await self.import_server(self.composite_proxy)
+        log.info(
+            f"✅ Created composite proxy with {len(enabled_servers)} servers ({mounted_servers.keys()})"
+        )
+        return True
 
-            # Track mounted servers for status reporting
-            for server_config in enabled_servers:
-                self.mounted_servers[server_config.name] = MountedServerInfo(
-                    config=server_config, proxy=self.composite_proxy
+    async def _mount_single_server(
+        self,
+        server_config: MCPServerConfig,
+        fastmcp_config: dict[str, Any],
+        oauth_manager: OAuthManager,
+    ) -> None:
+        """Mount a single MCP server with appropriate OAuth handling."""
+        server_name = server_config.name
+
+        # Check OAuth requirements for this server
+        remote_url = server_config.get_remote_url()
+        oauth_info = await oauth_manager.check_oauth_requirement(server_name, remote_url)
+
+        # Create proxy based on server type to avoid union type issues
+        if server_config.is_remote_server():
+            # Handle remote servers (with or without OAuth)
+            if not remote_url:
+                log.error(f"❌ Remote server {server_name} has no URL")
+                return
+
+            if oauth_info.status == OAuthStatus.AUTHENTICATED:
+                # Remote server with OAuth authentication
+                oauth_auth = oauth_manager.get_oauth_auth(
+                    server_name,
+                    remote_url,
+                    server_config.oauth_scopes,
+                    server_config.oauth_client_name,
                 )
+                if oauth_auth:
+                    client = FastMCPClient(remote_url, auth=oauth_auth)
+                    log.info(
+                        f"🔐 Created remote client with OAuth authentication for {server_name}"
+                    )
+                else:
+                    client = FastMCPClient(remote_url)
+                    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)
+                log.info(f"🌐 Created remote client for {server_name}")
+
+            # Log OAuth status warnings
+            if oauth_info.status == OAuthStatus.NEEDS_AUTH:
+                log.warning(
+                    f"⚠️ Server {server_name} requires OAuth but no valid tokens found. "
+                    f"Server will be mounted without authentication and may fail."
+                )
+            elif oauth_info.status == OAuthStatus.ERROR:
+                log.warning(f"⚠️ OAuth check failed for {server_name}: {oauth_info.error_message}")
 
-            log.info(f"✅ Created composite proxy with {len(enabled_servers)} servers")
-            return True
+            # Create proxy from remote client
+            proxy = FastMCP.as_proxy(client)
 
-        except Exception as e:
-            log.error(f"❌ Failed to create composite proxy: {e}")
-            return False
+        else:
+            # Local server - create proxy directly from config (avoids union type issue)
+            log.info(f"🔧 Creating local process proxy for {server_name}")
+            proxy = FastMCP.as_proxy(fastmcp_config)
 
-    async def mount_server(self, server_config: MCPServerConfig) -> bool:
-        """
-        Mount a single MCP server by rebuilding the composite proxy.
+        super().mount(proxy, prefix=server_name)
+        mounted_servers[server_name] = MountedServerInfo(config=server_config, proxy=proxy)
 
-        Args:
-            server_config: Configuration for the server to mount
+        server_type = "remote" if server_config.is_remote_server() else "local"
+        log.info(
+            f"✅ Mounted {server_type} server {server_name} (OAuth: {oauth_info.status.value})"
+        )
 
-        Returns:
-            True if mounting was successful, False otherwise
-        """
-        try:
-            # Check if server is already mounted
-            if server_config.name in self.mounted_servers:
-                log.info(f"Server {server_config.name} is already mounted")
-                return True
+    async def get_mounted_servers(self) -> list[ServerStatusInfo]:
+        """Get list of currently mounted servers."""
+        return [
+            ServerStatusInfo(name=name, config=mounted["config"].__dict__, mounted=True)
+            for name, mounted in mounted_servers.items()
+        ]
 
-            # Handle test servers separately
-            if server_config.command == "echo":
-                return await self._mount_test_server(server_config)
+    async def mount_server(self, server_name: str) -> bool:
+        """
+        Mount a server by name if not already mounted.
 
-            # For real servers, we need to rebuild the composite proxy
-            log.info(f"Mounting server {server_config.name} via composite proxy rebuild")
+        Returns True if newly mounted, False if it was already mounted or failed.
+        """
+        if server_name in mounted_servers:
+            log.info(f"🔁 Server {server_name} already mounted")
+            return False
 
-            # Get currently mounted servers and add the new one
-            current_configs = [mounted["config"] for mounted in self.mounted_servers.values()]
+        # Find server configuration
+        server_config: MCPServerConfig | None = next(
+            (s for s in Config().mcp_servers if s.name == server_name), None
+        )
 
-            # Add the new server if not already there
-            if server_config not in current_configs:
-                current_configs.append(server_config)
+        if server_config is None:
+            log.error(f"❌ Server configuration not found: {server_name}")
+            return False
 
-            # Rebuild composite proxy with new server list
-            return await self.create_composite_proxy(current_configs)
+        # Build minimal FastMCP backend config for just this server
+        fastmcp_config = self._convert_to_fastmcp_config([server_config])
+        if not fastmcp_config.get("mcpServers"):
+            log.error(f"❌ Invalid/empty MCP config for server: {server_name}")
+            return False
 
-        except Exception as e:
-            log.error(f"❌ Failed to mount server {server_config.name}: {e}")
+        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}")
             return False
 
-    async def unmount_server(self, server_name: str) -> bool:
+    async def unmount(self, server_name: str) -> bool:
         """
-        Unmount an MCP server and stop its subprocess.
+        Unmount a previously mounted server by name.
 
-        NOTE: For servers in the composite proxy, this will require rebuilding
-        the entire composite proxy without the specified server.
+        Returns True if it was unmounted, False if it wasn't mounted.
         """
-        try:
-            # Check if this is a test server (individually mounted)
-            if server_name in self.mounted_servers:
-                mounted = self.mounted_servers[server_name]
-                if mounted["config"].command == "echo":
-                    # Test server - handle individually
-                    await self._cleanup_mounted_server(server_name)
-                    return True
-
-                # Real server in composite proxy - needs full rebuild
-                log.warning(f"Unmounting {server_name} requires rebuilding composite proxy")
-                return await self._rebuild_composite_proxy_without(server_name)
-
-            log.warning(f"Server {server_name} not found in mounted servers")
-            return False
-
-        except Exception as e:
-            log.error(f"❌ Failed to unmount MCP server {server_name}: {e}")
+        info = mounted_servers.pop(server_name, None)
+        if info is None:
+            log.info(f"ℹ️  Server {server_name} was not mounted")
             return False
 
-    async def _rebuild_composite_proxy_without(self, excluded_server: str) -> bool:
-        """Rebuild the composite proxy without the specified server."""
-        try:
-            # Remove from mounted servers
-            await self._cleanup_mounted_server(excluded_server)
-
-            # Get remaining servers that should be in composite proxy
-            remaining_configs = [
-                mounted["config"]
-                for name, mounted in self.mounted_servers.items()
-                if mounted["config"].command != "echo" and name != excluded_server
-            ]
+        proxy = info.get("proxy")
 
-            if not remaining_configs:
-                log.info("No servers remaining for composite proxy")
-                self.composite_proxy = None
-                return True
+        # Manually remove from FastMCP managers' mounted lists
+        for manager_name in ("_tool_manager", "_resource_manager", "_prompt_manager"):
+            manager = getattr(self, manager_name, None)
+            mounted_list = getattr(manager, "_mounted_servers", None)
+            if mounted_list is None:
+                continue
 
-            # Rebuild composite proxy with remaining servers
-            log.info(f"Rebuilding composite proxy without {excluded_server}")
-            return await self.create_composite_proxy(remaining_configs)
+            # 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]
 
-        except Exception as e:
-            log.error(f"Failed to rebuild composite proxy: {e}")
-            return False
+            mounted_list[:] = new_list
 
-    async def _cleanup_mounted_server(self, server_name: str) -> None:
-        """Clean up mounted server resources."""
-        if server_name in self.mounted_servers:
-            del self.mounted_servers[server_name]
-            log.info(f"✅ Unmounted MCP server: {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()
 
-    async def get_mounted_servers(self) -> list[ServerStatusInfo]:
-        """Get list of currently mounted servers."""
-        return [
-            ServerStatusInfo(name=name, config=mounted["config"].__dict__, mounted=True)
-            for name, mounted in self.mounted_servers.items()
-        ]
+        log.info(f"🧹 Unmounted server {server_name} and cleared references")
+        return True
 
-    async def initialize(self, test_config: Any | None = None) -> None:
+    async def initialize(self) -> None:
         """Initialize the FastMCP server using unified composite proxy approach."""
         log.info("Initializing Single User MCP server with composite proxy")
-        config_to_use = test_config if test_config is not None else config
-        log.debug(f"Available MCP servers in config: {[s.name for s in config_to_use.mcp_servers]}")
+        log.debug(f"Available MCP servers in config: {[s.name for s in Config().mcp_servers]}")
 
         # Get all enabled servers
-        enabled_servers = [s for s in config_to_use.mcp_servers if s.enabled]
+        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]}"
         )
 
-        # Mount test servers individually (they don't go in composite proxy)
-        test_servers = [s for s in enabled_servers if s.command == "echo"]
-        for server_config in test_servers:
-            log.info(f"Mounting test server individually: {server_config.name}")
-            _ = await self._mount_test_server(server_config)
-
         # Create composite proxy for all real servers
         success = await self.create_composite_proxy(enabled_servers)
         if not success:
@@ -298,8 +324,8 @@ class SingleUserMCP(FastMCP[Any]):
     def _setup_demo_tools(self) -> None:
         """Set up built-in demo tools for testing."""
 
-        @self.tool()
-        def echo(text: str) -> str:  # noqa: ARG001
+        @self.tool()  # noqa
+        def builtin_echo(text: str) -> str:
             """
             Echo back the provided text.
 
@@ -312,8 +338,8 @@ class SingleUserMCP(FastMCP[Any]):
             log.info(f"🔊 Echo tool called with: {text}")
             return f"Echo: {text}"
 
-        @self.tool()
-        def get_server_info() -> dict[str, str | list[str] | int]:  # noqa: ARG001
+        @self.tool()  # noqa
+        def builtin_get_server_info() -> dict[str, str | list[str] | int]:
             """
             Get information about the Open Edison server.
 
@@ -323,13 +349,13 @@ class SingleUserMCP(FastMCP[Any]):
             log.info("ℹ️  Server info tool called")
             return {
                 "name": "Open Edison Single User",
-                "version": config.version,
-                "mounted_servers": list(self.mounted_servers.keys()),
-                "total_mounted": len(self.mounted_servers),
+                "version": Config().version,
+                "mounted_servers": list(mounted_servers.keys()),
+                "total_mounted": len(mounted_servers),
             }
 
-        @self.tool()
-        def get_security_status() -> dict[str, Any]:  # noqa: ARG001
+        @self.tool()  # noqa
+        def builtin_get_security_status() -> dict[str, Any]:
             """
             Get the current session's security status and data access summary.
 
@@ -353,18 +379,54 @@ class SingleUserMCP(FastMCP[Any]):
 
             return security_data
 
-        log.info("✅ Added built-in demo tools: echo, get_server_info, get_security_status")
+        @self.tool()  # noqa
+        async def builtin_get_available_tools() -> list[str]:
+            """
+            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()
+            available_tools: list[str] = []
+            log.debug(f"Raw tool list: {tool_list}")
+            perms = Permissions()
+            for tool in tool_list:
+                # Use the prefixed key (e.g., "filesystem_read_file") to match flattened permissions
+                perm_key = tool.key
+                try:
+                    is_enabled: bool = perms.is_tool_enabled(perm_key)
+                except PermissionsError:
+                    # Unknown in permissions → treat as disabled
+                    is_enabled = False
+                if is_enabled:
+                    # Return the invocable name (key), which matches the MCP-exposed name
+                    available_tools.append(tool.key)
+            return available_tools
+
+        @self.tool()  # noqa
+        async def builtin_tools_changed(ctx: Context) -> str:
+            """
+            Notify the MCP client that the tool list has changed. You should call this tool periodically
+            to ensure the client has the latest list of available tools.
+            """
+            await ctx.send_tool_list_changed()
+            await ctx.send_resource_list_changed()
+            await ctx.send_prompt_list_changed()
+
+            return "Notifications sent"
+
+        log.info(
+            "✅ Added built-in demo tools: echo, get_server_info, get_security_status, builtin_get_available_tools, builtin_tools_changed"
+        )
 
     def _setup_demo_resources(self) -> None:
         """Set up built-in demo resources for testing."""
 
-        @self.resource("config://app")
-        def get_app_config() -> dict[str, Any]:  # noqa: ARG001
+        @self.resource("config://app")  # noqa
+        def builtin_get_app_config() -> dict[str, Any]:
             """Get application configuration."""
             return {
-                "version": config.version,
-                "mounted_servers": list(self.mounted_servers.keys()),
-                "total_mounted": len(self.mounted_servers),
+                "version": Config().version,
+                "mounted_servers": list(mounted_servers.keys()),
+                "total_mounted": len(mounted_servers),
             }
 
         log.info("✅ Added built-in demo resources: config://app")
@@ -372,8 +434,8 @@ class SingleUserMCP(FastMCP[Any]):
     def _setup_demo_prompts(self) -> None:
         """Set up built-in demo prompts for testing."""
 
-        @self.prompt()
-        def summarize_text(text: str) -> str:
+        @self.prompt()  # noqa
+        def builtin_summarize_text(text: str) -> str:
             """Create a prompt to summarize the given text."""
             return f"""
         Please provide a concise, one-paragraph summary of the following text:

src/telemetry.py

@@ -18,9 +18,6 @@ Events/metrics captured (high level, install-unique ID for deaggregation):
 Configuration: see `TelemetryConfig` in `src.config`.
 """
 
-from __future__ import annotations
-
-import json
 import os
 import platform
 import traceback
@@ -37,7 +34,7 @@ from opentelemetry.sdk import metrics as ot_sdk_metrics
 from opentelemetry.sdk.metrics import export as ot_metrics_export
 from opentelemetry.sdk.resources import Resource  # type: ignore[reportMissingTypeStubs]
 
-from src.config import TelemetryConfig, config, get_config_dir
+from src.config import Config, TelemetryConfig, get_config_dir
 
 _initialized: bool = False
 _install_id: str | None = None
@@ -94,7 +91,7 @@ def _ensure_install_id() -> str:
 
 
 def _telemetry_enabled() -> bool:
-    tel_cfg = config.telemetry or TelemetryConfig()
+    tel_cfg = Config().telemetry or TelemetryConfig()
     return bool(tel_cfg.enabled)
 
 
@@ -134,7 +131,7 @@ def initialize_telemetry(override: TelemetryConfig | None = None) -> None:  # no
     if _initialized:
         return
 
-    telemetry_cfg = override if override is not None else (config.telemetry or TelemetryConfig())
+    telemetry_cfg = override if override is not None else (Config().telemetry or TelemetryConfig())
     if not telemetry_cfg.enabled:
         log.debug("Telemetry disabled by config")
         _initialized = True
@@ -182,7 +179,7 @@ def initialize_telemetry(override: TelemetryConfig | None = None) -> None:  # no
         os_description = platform.platform()
         host_arch = platform.machine()
         runtime_version = platform.python_version()
-        service_version = getattr(config, "version", "unknown")
+        service_version = Config().version
 
         # Attach a resource so metrics include service identifiers
         resource = Resource.create(
@@ -230,29 +227,6 @@ def initialize_telemetry(override: TelemetryConfig | None = None) -> None:  # no
     log.info("📈 Telemetry initialized")
 
 
-def force_flush_metrics(timeout_ms: int = 5000) -> bool:
-    """Force-flush metrics synchronously if a provider is initialized.
-
-    Returns True on success, False otherwise.
-    """
-    try:
-        provider = _provider
-        if provider is None:
-            return False
-        # Some providers expose force_flush(timeout_millis=...), others as force_flush() -> bool
-        if hasattr(provider, "force_flush"):
-            try:
-                # Try with timeout argument first
-                result = provider.force_flush(timeout_millis=timeout_ms)  # type: ignore[misc]
-            except TypeError:
-                result = provider.force_flush()
-            return bool(result)
-        return False
-    except Exception:  # noqa: BLE001
-        log.error("Force flush failed\n{}", traceback.format_exc())
-        return False
-
-
 def _common_attrs(extra: dict[str, Any] | None = None) -> dict[str, Any]:
     attrs: dict[str, Any] = {"install_id": _ensure_install_id(), "app": "open-edison"}
     if extra:
@@ -276,16 +250,6 @@ def record_tool_call_blocked(tool_name: str, reason: str) -> None:
     )
 
 
-@telemetry_recorder
-def record_tool_call_metadata(tool_name: str, metadata: dict[str, Any]) -> None:
-    if _tool_calls_metadata_counter is None:
-        return
-    metadata_str = json.dumps(metadata, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
-    _tool_calls_metadata_counter.add(
-        1, attributes=_common_attrs({"tool": tool_name, "metadata_json": metadata_str})
-    )
-
-
 @telemetry_recorder
 def set_servers_installed(count: int) -> None:
     if _servers_installed_gauge is None:

open_edison-0.1.17.dist-info/RECORD

@@ -1,14 +0,0 @@
-src/__init__.py,sha256=QWeZdjAm2D2B0eWhd8m2-DPpWvIP26KcNJxwEoU1oEQ,254
-src/__main__.py,sha256=kQsaVyzRa_ESC57JpKDSQJAHExuXme0rM5beJsYxFeA,161
-src/cli.py,sha256=9cJN6mRvjbCcpTyTdUVl47J7OB7bxzSy0h8tfVbHuQU,9982
-src/config.py,sha256=2a5rdImQmNGggL690PQprqZVsRUAJcdo8KS2Foj9N-U,9345
-src/server.py,sha256=h8sKLoHix27J_hgUXGZiJSJ1qcFSEpcrOmsTSpg0IWw,26544
-src/single_user_mcp.py,sha256=Ic8kOyUHN2VgytFyHk1OZ1JufXbGa3Cwm-plC-QQ7eY,14379
-src/telemetry.py,sha256=M8iZ7nTPA6BhbPna_xsEoTOOa7A81YyvZ0CkVYa_pPg,12619
-src/middleware/data_access_tracker.py,sha256=RZh1RCBYDEbvVIJPkDUz0bfLmK-xYIdV0lGbIxbJYc0,25966
-src/middleware/session_tracking.py,sha256=O-n8RvEVCUGAFGYny_gA7-MMQYSlvND-lj3oBZLCT3U,20046
-open_edison-0.1.17.dist-info/METADATA,sha256=aPZmsRIcpAizxFdwN6rZ8GfU3KsDlTfIjB3z8T_bFsA,9377
-open_edison-0.1.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_edison-0.1.17.dist-info/entry_points.txt,sha256=qNAkJcnoTXRhj8J--3PDmXz_TQKdB8H_0C9wiCtDIyA,72
-open_edison-0.1.17.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-open_edison-0.1.17.dist-info/RECORD,,