d365fo-client 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

d365fo_client/mcp/auth_server/auth/providers/apikey.py

@@ -0,0 +1,83 @@
+"""API Key authentication provider for FastMCP.
+
+This provider implements simple API key authentication using the Authorization header.
+Suitable for service-to-service authentication and simpler deployment scenarios.
+
+IMPORTANT: FastMCP uses BearerAuthBackend which extracts tokens from the Authorization header
+and calls token_verifier.verify_token(). Clients must send the API key as:
+    Authorization: Bearer <your-api-key>
+
+The token_verifier.verify_token() method performs constant-time comparison of the API key.
+"""
+
+from __future__ import annotations
+
+import secrets
+
+from pydantic import SecretStr
+
+from ..auth import AccessToken, TokenVerifier
+from d365fo_client.mcp.utilities.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class APIKeyVerifier(TokenVerifier):
+    """API Key token verifier for FastMCP.
+
+    This is a TokenVerifier that validates API keys sent as Bearer tokens.
+    FastMCP's BearerAuthBackend extracts the token from "Authorization: Bearer <token>"
+    and passes it to this verifier's verify_token() method.
+
+    This is a simpler alternative to OAuth for scenarios where:
+    - Service-to-service authentication is needed
+    - Simplified deployment without OAuth infrastructure
+    - Single-user or trusted client scenarios
+
+    Security features:
+    - Constant-time comparison to prevent timing attacks
+    - SecretStr storage to prevent accidental logging
+    - No token expiration (suitable for long-lived API keys)
+    """
+
+    def __init__(
+        self,
+        api_key: SecretStr,
+        base_url: str | None = None,
+        required_scopes: list[str] | None = None,
+    ):
+        """Initialize API key provider.
+
+        Args:
+            api_key: The secret API key value
+            base_url: Base URL of the server
+            required_scopes: Required scopes (for compatibility, not enforced for API keys)
+        """
+        super().__init__(base_url=base_url, required_scopes=required_scopes)
+        self.api_key = api_key
+
+    async def verify_token(self, token: str) -> AccessToken | None:
+        """Verify API key token.
+
+        This method is called by FastMCP's BearerAuthBackend after extracting
+        the token from "Authorization: Bearer <token>" header.
+
+        Args:
+            token: The API key extracted from the Authorization header
+
+        Returns:
+            AccessToken if valid, None otherwise
+        """
+        # Constant-time comparison to prevent timing attacks
+        if secrets.compare_digest(token, self.api_key.get_secret_value()):
+            logger.debug("API key authentication successful")
+            return AccessToken(
+                token=token,
+                scopes=self.required_scopes or [],
+                client_id="api_key_client",  # Fixed client_id for API key auth
+                expires_at=None,  # API keys don't expire
+                resource=None,
+            )
+
+        logger.warning("Invalid API key provided")
+        return None

d365fo_client/mcp/auth_server/auth/providers/azure.py

@@ -284,42 +284,110 @@ class AzureProvider(OAuthProxy):
 
     async def register_client(self, client_info: OAuthClientInformationFull) -> None:
         """Register a new MCP client, validating redirect URIs if configured."""
-        result = await super().register_client(client_info)
-        self._save_clients()
-        return result
+        await super().register_client(client_info)
+        try:
+            self._save_clients()
+        except Exception as e:
+            logger.error(f"Failed to persist client registration: {e}")
+            # Don't raise here as the client is already registered in memory
 
-    def _save_clients(self) -> str | None:
+    def _save_clients(self) -> None:
+        """Save client data to persistent storage.
+        
+        Raises:
+            ValueError: If clients_storage_path is not configured
+            OSError: If file operations fail
+        """
         if not self.clients_storage_path:
             logger.warning("No clients storage path configured. Skipping client save.")
-            return None
+            return
         
-        # Store self._clients to clients.json
         try:
-            client_json_path = Path(self.clients_storage_path) / "clients.json"
+            # Ensure the storage directory exists
+            storage_dir = Path(self.clients_storage_path)
+            storage_dir.mkdir(parents=True, exist_ok=True)
+            
+            client_json_path = storage_dir / "clients.json"
+            
             # Convert OAuthClientInformationFull objects to dictionaries for JSON serialization
-            clients_dict = {
-                client_id: client.model_dump() if hasattr(client, 'model_dump') else client.__dict__
-                for client_id, client in self._clients.items()
-            }
-            with client_json_path.open("w") as f:
-                json.dump(clients_dict, f, indent=2)
+            # Use mode="json" to properly serialize complex types like AnyUrl
+            clients_dict = {}
+            for client_id, client in self._clients.items():
+                try:
+                    if hasattr(client, 'model_dump'):
+                        # Use json mode to ensure proper serialization of complex types (e.g., AnyUrl)
+                        clients_dict[client_id] = client.model_dump(mode="json")
+                    else:
+                        # Fallback for non-Pydantic objects (shouldn't happen with OAuthClientInformationFull)
+                        clients_dict[client_id] = client.__dict__
+                except Exception as client_error:
+                    logger.error(f"Failed to serialize client {client_id}: {client_error}")
+                    continue
+            
+            # Write to temporary file first, then rename for atomic operation
+            temp_path = client_json_path.with_suffix('.tmp')
+            with temp_path.open("w") as f:
+                json.dump(clients_dict, f, indent=2, ensure_ascii=False)
+            
+            # Atomic rename
+            temp_path.replace(client_json_path)
+            
+            logger.debug(f"Successfully saved {len(clients_dict)} clients to {client_json_path}")
+            
         except Exception as e:
-            logger.error(f"Failed to write client data to {client_json_path}: {e}")
+            logger.error(f"Failed to save client data to {self.clients_storage_path}: {e}")
+            raise
 
     def _load_clients(self) -> None:
+        """Load client data from persistent storage.
+        
+        Loads clients from the JSON file if it exists and is valid.
+        Invalid client data is logged and skipped.
+        """
         if not self.clients_storage_path:
+            logger.debug("No clients storage path configured. Skipping client load.")
             return
         
-         # Load existing clients from storage if path is provided
-    
         try:
             client_json_path = Path(self.clients_storage_path) / "clients.json"
-            if client_json_path.exists():
-                with client_json_path.open("r") as f:
-                    clients_data = json.load(f)
-                    for client_id, client_info in clients_data.items():
-                        # Ensure client_id is a string (it should be from JSON, but type checking requires this)
-                        if isinstance(client_id, str):
-                            self._clients[client_id] = OAuthClientInformationFull.model_validate(client_info)
+            
+            if not client_json_path.exists():
+                logger.debug(f"Client storage file {client_json_path} does not exist. Starting with empty client registry.")
+                return
+            
+            # Read and parse the JSON file
+            with client_json_path.open("r", encoding="utf-8") as f:
+                clients_data = json.load(f)
+            
+            if not isinstance(clients_data, dict):
+                logger.error(f"Invalid client data format in {client_json_path}: expected dict, got {type(clients_data)}")
+                return
+            
+            loaded_count = 0
+            for client_id, client_info in clients_data.items():
+                try:
+                    # Validate client_id is a string
+                    if not isinstance(client_id, str):
+                        logger.warning(f"Skipping client with non-string ID: {client_id} (type: {type(client_id)})")
+                        continue
+                    
+                    # Validate and restore the client object
+                    if not isinstance(client_info, dict):
+                        logger.warning(f"Skipping client {client_id}: invalid data format (expected dict, got {type(client_info)})")
+                        continue
+                    
+                    # Use Pydantic model_validate to restore the object with proper validation
+                    client_obj = OAuthClientInformationFull.model_validate(client_info)
+                    self._clients[client_id] = client_obj
+                    loaded_count += 1
+                    
+                except Exception as client_error:
+                    logger.error(f"Failed to load client {client_id}: {client_error}")
+                    continue
+            
+            logger.info(f"Successfully loaded {loaded_count} clients from {client_json_path}")
+            
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON in client storage file {client_json_path}: {e}")
         except Exception as e:
             logger.error(f"Failed to load clients from {client_json_path}: {e}")

d365fo_client/mcp/fastmcp_main.py

@@ -19,6 +19,7 @@ from d365fo_client.mcp.fastmcp_utils import create_default_profile_if_needed, lo
 from d365fo_client.profile_manager import ProfileManager
 from d365fo_client.settings import get_settings
 from mcp.server.auth.settings import  AuthSettings,ClientRegistrationOptions
+from d365fo_client.mcp.auth_server.auth.providers.apikey import APIKeyVerifier
 
 
 
@@ -120,6 +121,7 @@ Environment Variables:
   D365FO_MCP_AUTH_TENANT_ID    Azure AD tenant ID for authentication
   D365FO_MCP_AUTH_BASE_URL     http://localhost:8000
   D365FO_MCP_AUTH_REQUIRED_SCOPES  User.Read,email,openid,profile
+  D365FO_MCP_API_KEY_VALUE      API key for authentication (send as: Authorization: Bearer <key>)
   D365FO_LOG_LEVEL               Logging level (DEBUG, INFO, WARNING, ERROR)
   D365FO_LOG_FILE                Custom log file path (default: ~/.d365fo-mcp/logs/fastmcp-server.log)
   D365FO_META_CACHE_DIR          Metadata cache directory (default: ~/.d365fo-mcp/cache)
@@ -254,63 +256,93 @@ logger.info(f"Startup Mode: {settings.get_startup_mode()}")
 logger.info(f"Client Credentials: {'Configured' if settings.has_client_credentials() else 'Not configured'}")
 logger.info("====================================")
 
-if is_remote_transport and not settings.has_mcp_auth_credentials():
+# Validate authentication for remote transports
+if is_remote_transport:
+    has_oauth = settings.has_mcp_auth_credentials()
+    has_api_key = settings.has_mcp_api_key_auth()
+
+    # Must have either OAuth or API key
+    if not has_oauth and not has_api_key:
+        logger.error(
+            "Error: Remote transports (SSE/HTTP) require authentication. "
+            "Please configure either:\n"
+            "  OAuth: D365FO_MCP_AUTH_CLIENT_ID, D365FO_MCP_AUTH_CLIENT_SECRET, "
+            "D365FO_MCP_AUTH_TENANT_ID, D365FO_MCP_AUTH_BASE_URL, D365FO_MCP_AUTH_REQUIRED_SCOPES\n"
+            "  OR\n"
+            "  API Key: D365FO_MCP_API_KEY_VALUE, D365FO_MCP_API_KEY_HEADER_NAME (optional)"
+        )
+        sys.exit(1)
 
-    logger.error("Warning: Client credentials (D365FO_MCP_AUTH_CLIENT_ID and D365FO_MCP_AUTH_CLIENT_SECRET, D365FO_MCP_AUTH_TENANT_ID,D365FO_MCP_AUTH_BASE_URL and D365FO_MCP_AUTH_REQUIRED_SCOPES) are not set. " +
-                   "Remote transports require authentication to the D365FO environment.")
-    sys.exit(1)    
+    # OAuth takes precedence if both are configured
+    if has_oauth and has_api_key:
+        logger.warning(
+            "Both OAuth and API Key authentication configured. "
+            "Using OAuth (takes precedence)."
+        )    
 
-auth_provider: AzureProvider | None = None
+# Initialize authentication provider
+auth_provider: AzureProvider | APIKeyVerifier | None = None  # type: ignore
 auth: AuthSettings | None = None
 
 if is_remote_transport:
-    assert settings.mcp_auth_client_id is not None
-    assert settings.mcp_auth_client_secret is not None
-    assert settings.mcp_auth_tenant_id is not None
-    assert settings.mcp_auth_base_url is not None
-    assert settings.mcp_auth_required_scopes is not None
-    required_scopes=settings.mcp_auth_required_scopes_list()
-
-    # if "AX.FullAccess" not in required_scopes:
-    #     logger.warning("Warning: 'AX.FullAccess' scope is not supported. Adding it automatically.")
-    #     required_scopes.append("https://erp.dynamics.com/AX.FullAccess")
-
-    # Initialize authorization settings
-    auth_provider = AzureProvider(
-        client_id=settings.mcp_auth_client_id,  # Your Azure App Client ID
-        client_secret=settings.mcp_auth_client_secret,                 # Your Azure App Client Secret
-        tenant_id=settings.mcp_auth_tenant_id, # Your Azure Tenant ID (REQUIRED)
-        base_url=settings.mcp_auth_base_url,                   # Must match your App registration
-        required_scopes=required_scopes or ["User.Read"],  # type: ignore # Scopes your app needs
-        redirect_path="/auth/callback",  # Ensure callback path is explicit
-        clients_storage_path=config_path or ...
-    )
-    from mcp.shared.auth import OAuthClientInformationFull
-
-    # auth_provider._clients["eae68fdd-610b-47c5-9907-709c7452f1b3"] = OAuthClientInformationFull(
-    #     client_id="5eae68fdd-610b-47c5-9907-709c7452f1b3",
-    #     client_name="Test Client",
-    #     redirect_uris=[AnyUrl("http://127.0.0.1:33418")],
-    #     scope=",".join(required_scopes)
-    # )
-
+    has_oauth = settings.has_mcp_auth_credentials()
+    has_api_key = settings.has_mcp_api_key_auth()
+
+    if has_oauth:
+        # OAuth authentication setup
+        logger.info("Initializing OAuth authentication with Azure AD")
+
+        assert settings.mcp_auth_client_id is not None
+        assert settings.mcp_auth_client_secret is not None
+        assert settings.mcp_auth_tenant_id is not None
+        assert settings.mcp_auth_base_url is not None
+        assert settings.mcp_auth_required_scopes is not None
+        required_scopes = settings.mcp_auth_required_scopes_list()
+
+        # Initialize authorization settings
+        auth_provider = AzureProvider(
+            client_id=settings.mcp_auth_client_id,
+            client_secret=settings.mcp_auth_client_secret,
+            tenant_id=settings.mcp_auth_tenant_id,
+            base_url=settings.mcp_auth_base_url,
+            required_scopes=required_scopes or ["User.Read"],  # type: ignore
+            redirect_path="/auth/callback",
+            clients_storage_path=config_path or ...
+        )
 
-    auth=AuthSettings(
+        auth = AuthSettings(
             issuer_url=AnyHttpUrl(settings.mcp_auth_base_url),
             client_registration_options=ClientRegistrationOptions(
                 enabled=True,
-                valid_scopes=required_scopes or ["User.Read"], # type: ignore
-                default_scopes=required_scopes or ["User.Read"], # type: ignore
+                valid_scopes=required_scopes or ["User.Read"],  # type: ignore
+                default_scopes=required_scopes or ["User.Read"],  # type: ignore
             ),
-            required_scopes=required_scopes or ["User.Read"], # type: ignore
+            required_scopes=required_scopes or ["User.Read"],  # type: ignore
             resource_server_url=AnyHttpUrl(settings.mcp_auth_base_url),
-            
+        )
+
+    elif has_api_key:
+        # API Key authentication setup
+        logger.info("Initializing API Key authentication")
+
+        from d365fo_client.mcp.auth_server.auth.providers.apikey import APIKeyVerifier
+
+        auth_provider = APIKeyVerifier(  # type: ignore
+            api_key=settings.mcp_api_key_value,  # type: ignore
+            base_url=settings.mcp_auth_base_url,
+        )
+
+        # For API Key authentication
+        auth = AuthSettings(
+            issuer_url=AnyHttpUrl(settings.mcp_auth_base_url) if settings.mcp_auth_base_url else AnyHttpUrl("http://localhost"),
+            resource_server_url=None
         )
 
 # Initialize FastMCP server with configuration
 mcp = FastMCP(
     name=server_config.get("name", "d365fo-mcp-server"),
-    auth_server_provider=auth_provider,
+    auth_server_provider=auth_provider if isinstance(auth_provider, AzureProvider) else None,
+    token_verifier=auth_provider if isinstance(auth_provider, APIKeyVerifier) else None,
     auth=auth,
     instructions=server_config.get(
         "instructions",
@@ -326,16 +358,33 @@ mcp = FastMCP(
 
 )
 
-if is_remote_transport:
+# Add OAuth callback route only for Azure OAuth provider
+if is_remote_transport and isinstance(auth_provider, AzureProvider):
     from starlette.requests import Request
     from starlette.responses import RedirectResponse
-    
+
     @mcp.custom_route(path=auth_provider._redirect_path, methods=["GET"]) # type: ignore
     async def handle_idp_callback(request: Request) -> RedirectResponse:
         return await auth_provider._handle_idp_callback(request) # type: ignore
 
+# Initialize FastD365FOMCPServer
 server = FastD365FOMCPServer(mcp, config, profile_manager=profile_manager)
 
+# Configure API Key authentication if enabled
+if is_remote_transport:
+    from d365fo_client.mcp.auth_server.auth.providers.apikey import APIKeyVerifier
+
+    if isinstance(auth_provider, APIKeyVerifier):
+
+        logger.info("API Key authentication configured successfully")
+        logger.info("=" * 60)
+        logger.info("IMPORTANT: Clients must authenticate using:")
+        logger.info("  Authorization: Bearer <your-api-key>")
+        logger.info("")
+        logger.info("Example:")
+        logger.info(f"  curl -H 'Authorization: Bearer YOUR_KEY' http://localhost:{transport_config.get('http', {}).get('port', 8000)}/")
+        logger.info("=" * 60)
+
 logger.info("FastD365FOMCPServer initialized successfully")
 
 

d365fo_client/settings.py

@@ -5,7 +5,7 @@ from enum import Enum
 from pathlib import Path
 from typing import Literal, Optional
 
-from pydantic import Field, field_validator
+from pydantic import Field, SecretStr, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from .utils import get_default_cache_directory
@@ -104,7 +104,15 @@ class D365FOSettings(BaseSettings):
         description="MCP authentication required scopes (comma-separated)",
         alias="D365FO_MCP_AUTH_REQUIRED_SCOPES"
     )
-    
+
+    # === MCP API Key Authentication Settings ===
+
+    mcp_api_key_value: Optional[SecretStr] = Field(
+        default=None,
+        description="API key value for authentication (send as Authorization: Bearer <key>)",
+        alias="D365FO_MCP_API_KEY_VALUE"
+    )
+
     # === MCP Server Transport Settings ===
     
     mcp_transport: TransportProtocol = Field(
@@ -285,6 +293,10 @@ class D365FOSettings(BaseSettings):
     def has_mcp_auth_credentials(self) -> bool:
         """Check if MCP authentication credentials are configured."""
         return all([self.mcp_auth_client_id, self.mcp_auth_client_secret, self.mcp_auth_tenant_id])
+
+    def has_mcp_api_key_auth(self) -> bool:
+        """Check if API key authentication is configured."""
+        return self.mcp_api_key_value is not None
     
     def get_startup_mode(self) -> Literal["profile_only", "default_auth", "client_credentials"]:
         """Determine startup mode based on configuration."""

{d365fo_client-0.3.0.dist-info → d365fo_client-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d365fo-client
-Version: 0.3.0
+Version: 0.3.1
 Summary: Microsoft Dynamics 365 Finance & Operations client
 Author-email: Muhammad Afzaal <mo@thedataguy.pro>
 License-Expression: MIT

{d365fo_client-0.3.0.dist-info → d365fo_client-0.3.1.dist-info}/RECORD

@@ -15,12 +15,12 @@ d365fo_client/profile_manager.py,sha256=43_V82r0gugEgn5o2EbGN-JDleJaEFMPH9Ak4KmJ
 d365fo_client/profiles.py,sha256=3EwD9zYfyjdiuPPaul-_qvL8GUPiky_m6kyZqoYN20I,8106
 d365fo_client/query.py,sha256=wOZjXEtGzPcd5mRfdkpMZTHZdSId44gLSboJs4LeSaw,5028
 d365fo_client/session.py,sha256=4OIR61eYQHALPmbXZ446Ko4j5ttvozDxDRnMikogBys,1841
-d365fo_client/settings.py,sha256=Pq5GnJA6B15RDKCbaIR8XQQ2Leys3RvqI1sfm3f2qcA,10854
+d365fo_client/settings.py,sha256=kkoB1UUo2Hwkz42hlpj35g_ih-BaP6vHCLPRea6N_10,11284
 d365fo_client/sync_models.py,sha256=BOYR3zCaqPwrvAQq2pM3cBb6Pt9SU7pxKKTAJLsoVZA,9247
 d365fo_client/utils.py,sha256=JywzDfgEI4Ei3l6xnAA0aw15RThWAT8mY-C4tpTrToU,6846
 d365fo_client/mcp/__init__.py,sha256=IT55UrOYT3kC7DS5zlALPilVu_KEIlVgIm3WR7QmEcQ,673
 d365fo_client/mcp/client_manager.py,sha256=LoCpRl_WeURXVjv8ugBFFlWqQ3bUO-HpP94CwC5c010,9705
-d365fo_client/mcp/fastmcp_main.py,sha256=0kzxugFnqRyiiWaEmeX2_ZSmnn5TzJKwB_jeRiXafC8,13934
+d365fo_client/mcp/fastmcp_main.py,sha256=ofyYvez5UE9hVQ4q73us--oSrKbqTpj0t0MfaVJaWcA,15787
 d365fo_client/mcp/fastmcp_server.py,sha256=xm1gugM8TX0n613n9MqRFDlBL9pK2-5jsM2kpbsCt9o,23873
 d365fo_client/mcp/fastmcp_utils.py,sha256=uBg4iziIEVN-MiMxtMwSg8a4RPseW6ltC-HKdGq-dWw,18250
 d365fo_client/mcp/main.py,sha256=sNG6IIs3SvzumUhfzRH6aNzN2T7OZrPNl7_Yx-Fkt8I,5333
@@ -33,7 +33,8 @@ d365fo_client/mcp/auth_server/auth/auth.py,sha256=YLM04cwXHURaI1o3liPhAw-37YAnDO
 d365fo_client/mcp/auth_server/auth/oauth_proxy.py,sha256=EOveccoyF6wkRuf1ccQ-3QHH1n8JGzinKzbrbyodQHs,42253
 d365fo_client/mcp/auth_server/auth/redirect_validation.py,sha256=Jlhela9xpTbw4aWnQ04A5Z-TW0HYOC3f9BMsq3NXx1Q,2000
 d365fo_client/mcp/auth_server/auth/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-d365fo_client/mcp/auth_server/auth/providers/azure.py,sha256=MyOkyz_c19MB9RrcaM-mXuTbIlRK-Z5Z-o2AnT7N-jk,12824
+d365fo_client/mcp/auth_server/auth/providers/apikey.py,sha256=g9ZvzE40fjRFrth-0FhFiBLFSfCFV2uV5jIBlDr0F2Y,2960
+d365fo_client/mcp/auth_server/auth/providers/azure.py,sha256=3oyVz6AAoHNQP7UKnSmNA9jDOQY9kNbgawgE181vF_4,16032
 d365fo_client/mcp/auth_server/auth/providers/bearer.py,sha256=uz7sbxXQobem3YV6HUSf-QUOnkhhnmjyXoUEu5AIIkc,891
 d365fo_client/mcp/auth_server/auth/providers/jwt.py,sha256=Xj9W8WsENjeT8U3Ncic69gxQREkPp1P6LxQodE3UI5A,19542
 d365fo_client/mcp/mixins/__init__.py,sha256=b7sJ77m-7EmT5PKEuMkIIBAI6ISTG2-ZnNNQQBVYbTc,778
@@ -76,9 +77,9 @@ d365fo_client/metadata_v2/search_engine_v2.py,sha256=s_XVqP3LLog19IAv8DpxVUS7TFR
 d365fo_client/metadata_v2/sync_manager_v2.py,sha256=JM8ThiXyXKYlnGaH3iwbBlPd9RFkDr0-ivkuHLAIo40,34090
 d365fo_client/metadata_v2/sync_session_manager.py,sha256=XWxjFGwgnm6S4lzeYqyPqZgvpcqzK3tBaxnQ-srgYrg,44365
 d365fo_client/metadata_v2/version_detector.py,sha256=t9mKaeT4SKb13LmIq5fB6PTLOZn5Jp7ZUqQobntNEUg,15791
-d365fo_client-0.3.0.dist-info/licenses/LICENSE,sha256=idD7NJAZD7ognzZVyKjDxVYDCmngEIt0WxA_uB1v0iI,1071
-d365fo_client-0.3.0.dist-info/METADATA,sha256=AbDB8_EoFT_MaATG9HDXXPvIQ16sJ3dAw78HrLICB2s,59480
-d365fo_client-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-d365fo_client-0.3.0.dist-info/entry_points.txt,sha256=jCw6TT6lLRKzAWTSzxMhdYbTT-m5v0LDcZ9Zun4JM-0,174
-d365fo_client-0.3.0.dist-info/top_level.txt,sha256=ZbvqO90RjhOW0cjFCAEeP8OFyITbhrij2vC3k4bWERQ,14
-d365fo_client-0.3.0.dist-info/RECORD,,
+d365fo_client-0.3.1.dist-info/licenses/LICENSE,sha256=idD7NJAZD7ognzZVyKjDxVYDCmngEIt0WxA_uB1v0iI,1071
+d365fo_client-0.3.1.dist-info/METADATA,sha256=ogDZb7EH-gowVAWEGVBpx2MPk7le7ZcgfyZT6ZtHnow,59480
+d365fo_client-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+d365fo_client-0.3.1.dist-info/entry_points.txt,sha256=jCw6TT6lLRKzAWTSzxMhdYbTT-m5v0LDcZ9Zun4JM-0,174
+d365fo_client-0.3.1.dist-info/top_level.txt,sha256=ZbvqO90RjhOW0cjFCAEeP8OFyITbhrij2vC3k4bWERQ,14
+d365fo_client-0.3.1.dist-info/RECORD,,