open-edison 0.1.19__py3-none-any.whl → 0.1.29__py3-none-any.whl

src/single_user_mcp.py

@@ -8,20 +8,22 @@ Handles MCP protocol communication with running servers using a unified composit
 from typing import Any, TypedDict
 
 from fastmcp import Client as FastMCPClient
-from fastmcp import FastMCP
+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
 
 
@@ -29,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,9 +49,8 @@ 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
+        # Disable error masking so upstream error details are preserved in responses
+        super().__init__(name="open-edison-single-user", mask_error_details=False)
 
         # Add session tracking middleware for data access monitoring
         self.add_middleware(SessionTrackingMiddleware())
@@ -68,10 +73,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,
@@ -86,15 +87,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.
@@ -112,81 +104,194 @@ class SingleUserMCP(FastMCP[Any]):
             log.info("No real servers to mount in composite proxy")
             return True
 
-        # Import the composite proxy into this main server
-        # Tools and resources will be automatically namespaced by server name
+        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
-            proxy = FastMCP.as_proxy(FastMCPClient(fastmcp_config))
-            self.mount(proxy, prefix=server_name)
-            self.mounted_servers[server_name] = MountedServerInfo(config=server_config, proxy=proxy)
+
+            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 ({self.mounted_servers.keys()})"
+            f"✅ Created composite proxy with {len(enabled_servers)} servers ({mounted_servers.keys()})"
         )
         return True
 
-    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
-            ]
-
-            if not remaining_configs:
-                log.info("No servers remaining for composite proxy")
-                self.composite_proxy = None
-                return True
-
-            # Rebuild composite proxy with remaining servers
-            log.info(f"Rebuilding composite proxy without {excluded_server}")
-            return await self.create_composite_proxy(remaining_configs)
-
-        except Exception as e:
-            log.error(f"Failed to rebuild composite proxy: {e}")
-            return False
-
-    async def _cleanup_mounted_server(self, server_name: str) -> None:
-        """Clean up mounted server resources."""
-        # TODO not sure this is possible for the self object? i.e. there is no self.unmount
-        if server_name in self.mounted_servers:
-            del self.mounted_servers[server_name]
-            log.info(f"✅ Unmounted MCP server: {server_name}")
+    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}")
+
+            # Create proxy from remote client
+            proxy = FastMCP.as_proxy(client)
+
+        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)
+
+        super().mount(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"
+        log.info(
+            f"✅ Mounted {server_type} server {server_name} (OAuth: {oauth_info.status.value})"
+        )
 
     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()
+            for name, mounted in mounted_servers.items()
         ]
 
-    async def initialize(self, test_config: Any | None = None) -> None:
+    async def mount_server(self, server_name: str) -> bool:
+        """
+        Mount a server by name if not already mounted.
+
+        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
+
+        # Find server configuration
+        server_config: MCPServerConfig | None = next(
+            (s for s in Config().mcp_servers if s.name == server_name), None
+        )
+
+        if server_config is None:
+            log.error(f"❌ Server configuration not found: {server_name}")
+            return False
+
+        # 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
+
+        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(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)
+        if info is None:
+            log.info(f"ℹ️  Server {server_name} was not mounted")
+            return False
+
+        proxy = info.get("proxy")
+
+        # 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
+
+            # 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]
+
+            mounted_list[:] = new_list
+
+        # 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()
+
+        log.info(f"🧹 Unmounted server {server_name} and cleared references")
+        return True
+
+    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)
+        # Unmount all servers
+        for server_name in list(mounted_servers.keys()):
+            await self.unmount(server_name)
 
         # Create composite proxy for all real servers
         success = await self.create_composite_proxy(enabled_servers)
@@ -196,79 +301,10 @@ class SingleUserMCP(FastMCP[Any]):
 
         log.info("✅ Single User MCP server initialized with composite proxy")
 
-    async def reinitialize(self, test_config: Any | None = None) -> dict[str, Any]:
-        """
-        Reinitialize all MCP servers by cleaning up existing ones and reloading config.
-
-        This method:
-        1. Cleans up all mounted servers and MCP proxies
-        2. Reloads the configuration
-        3. Reinitializes all enabled servers
-
-        Args:
-            test_config: Optional test configuration to use instead of reloading from disk
-
-        Returns:
-            Dictionary with reinitialization status and details
-        """
-        log.info("🔄 Reinitializing all MCP servers")
-
-        try:
-            # Step 1: Clean up existing mounted servers and proxies
-            log.info("Cleaning up existing mounted servers and proxies")
-
-            # Clean up composite proxy if it exists
-            if self.composite_proxy is not None:
-                log.info("Cleaning up composite proxy")
-                self.composite_proxy = None
-
-            # Clean up all mounted servers
-            mounted_server_names = list(self.mounted_servers.keys())
-            for server_name in mounted_server_names:
-                await self._cleanup_mounted_server(server_name)
-
-            # Clear the mounted servers dictionary completely
-            self.mounted_servers.clear()
-
-            log.info(f"✅ Cleaned up {len(mounted_server_names)} mounted servers")
-
-            # Step 2: Reload configuration if not using test config
-            config_to_use = test_config
-            if test_config is None:
-                log.info("Reloading configuration from disk")
-                # Import here to avoid circular imports
-                from src.config import Config
-
-                config_to_use = Config.load()
-                log.info("✅ Configuration reloaded from disk")
-
-            # Step 3: Reinitialize all servers
-            log.info("Reinitializing servers with fresh configuration")
-            await self.initialize(config_to_use)
-
-            # Step 4: Get final status
-            final_mounted = await self.get_mounted_servers()
-
-            result = {
-                "status": "success",
-                "message": "MCP servers reinitialized successfully",
-                "cleaned_up_servers": mounted_server_names,
-                "final_mounted_servers": [server["name"] for server in final_mounted],
-                "total_final_mounted": len(final_mounted),
-            }
-
-            log.info(
-                f"✅ Reinitialization complete. Final mounted servers: {result['final_mounted_servers']}"
-            )
-            return result
-
-        except Exception as e:
-            log.error(f"❌ Failed to reinitialize MCP servers: {e}")
-            return {
-                "status": "error",
-                "message": f"Failed to reinitialize MCP servers: {str(e)}",
-                "error": str(e),
-            }
+        # 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()
 
     def _calculate_risk_level(self, trifecta: dict[str, bool]) -> str:
         """
@@ -298,8 +334,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 +348,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 +359,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 +389,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.trace(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 +444,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.19.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=cXW16m6UMUofQFbtM6E2EasxClhWAS-955BuasNupmM,29557
-src/single_user_mcp.py,sha256=3pDBMant1DNlNPeW_NWD-uFyLrA-qNrx6sDHgDKsDfM,14457
-src/telemetry.py,sha256=M8iZ7nTPA6BhbPna_xsEoTOOa7A81YyvZ0CkVYa_pPg,12619
-src/middleware/data_access_tracker.py,sha256=N4g_T-JF9W7yzRIFRasY-JA7ha-Zt_Ov4nSn-TCq-Ps,27026
-src/middleware/session_tracking.py,sha256=O-n8RvEVCUGAFGYny_gA7-MMQYSlvND-lj3oBZLCT3U,20046
-open_edison-0.1.19.dist-info/METADATA,sha256=88QHl-ngXl0uFZwYUO2dVMtxmQ0T3eyVUE7NyP6jXAY,10905
-open_edison-0.1.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-open_edison-0.1.19.dist-info/entry_points.txt,sha256=qNAkJcnoTXRhj8J--3PDmXz_TQKdB8H_0C9wiCtDIyA,72
-open_edison-0.1.19.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-open_edison-0.1.19.dist-info/RECORD,,