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

d365fo_client/__init__.py

@@ -172,7 +172,7 @@ from .labels import resolve_labels_generic, resolve_labels_generic_with_cache
 from .main import main
 
 # MCP Server
-from .mcp import D365FOClientManager, D365FOMCPServer
+from .mcp import D365FOClientManager, D365FOMCPServer, FastD365FOMCPServer
 
 # V2 Metadata Cache (recommended - now the only implementation)
 from .metadata_v2 import MetadataCacheV2, VersionAwareSearchEngine
@@ -195,6 +195,7 @@ from .models import (
 from .output import OutputFormatter
 from .profile_manager import ProfileManager
 from .profiles import Profile
+from .settings import D365FOSettings, get_settings, reset_settings
 from .utils import (
     ensure_directory_exists,
     extract_domain_from_url,
@@ -250,11 +251,16 @@ __all__ = [
     "Profile",
     "ProfileManager",
     "CLIManager",
+    # Settings
+    "D365FOSettings",
+    "get_settings", 
+    "reset_settings",
     # Legacy aliases
     "CLIProfile",
     "EnvironmentProfile",
     # MCP Server
     "D365FOMCPServer",
+    "FastD365FOMCPServer",
     "D365FOClientManager",
     # Entry point
     "main",

d365fo_client/auth.py

@@ -1,7 +1,7 @@
 """Authentication utilities for D365 F&O client."""
 
 from datetime import datetime
-from typing import Optional
+from typing import Optional, Union
 
 from azure.identity import ClientSecretCredential, DefaultAzureCredential
 
@@ -22,13 +22,13 @@ class AuthenticationManager:
         self._token = None
         self._token_expires = None
         self._credential_manager = CredentialManager()
-        self.credential = None  # Will be set by _setup_credentials
+        self.credential: Optional[Union[ClientSecretCredential, DefaultAzureCredential]] = None  # Will be set by _setup_credentials
 
     async def _setup_credentials(self):
         """Setup authentication credentials with support for credential sources"""
         
         # Check if credential source is specified in config
-        credential_source = getattr(self.config, 'credential_source', None)
+        credential_source = self.config.credential_source
         
         if credential_source is not None:
             # Use credential source to get credentials
@@ -46,22 +46,8 @@ class AuthenticationManager:
         
         # Fallback to existing logic for backward compatibility
   
-        if (
-            self.config.client_id
-            and self.config.client_secret
-            and self.config.tenant_id
-        ):
-            self.credential = ClientSecretCredential(
-                tenant_id=self.config.tenant_id,
-                client_id=self.config.client_id,
-                client_secret=self.config.client_secret,
-            )
-        elif self.config.use_default_credentials:
-            self.credential = DefaultAzureCredential()
-        else:
-            raise ValueError(
-                "Must provide either use_default_credentials=True, client credentials, or credential_source"
-            )
+        self.credential = DefaultAzureCredential()
+      
 
     async def get_token(self) -> str:
         """Get authentication token
@@ -77,6 +63,9 @@ class AuthenticationManager:
         if self.credential is None:
             await self._setup_credentials()
 
+        if self.credential is None:
+            raise ValueError("Authentication credentials are not set up.")
+
         if (
             self._token
             and self._token_expires
@@ -86,8 +75,7 @@ class AuthenticationManager:
 
         # Try different scopes
         scopes_to_try = [
-            f"{self.config.base_url}/.default",
-            f"{self.config.client_id}/.default" if self.config.client_id else None,
+            f"{self.config.base_url.rstrip('/')}/.default",
         ]
 
         for scope in scopes_to_try:

d365fo_client/cli.py

@@ -532,10 +532,13 @@ class CLIManager:
 
             profile_list = []
             for name, profile in profiles.items():
+                # Determine auth mode based on credential source
+                auth_mode = "default" if profile.credential_source is None else "explicit"
+                
                 profile_info = {
                     "name": name,
                     "base_url": profile.base_url,
-                    "auth_mode": profile.auth_mode,
+                    "auth_mode": auth_mode,
                     "default": (
                         "✓" if default_profile and default_profile.name == name else ""
                     ),
@@ -563,22 +566,22 @@ class CLIManager:
                 return 1
 
             # Convert profile to dict for display
+            auth_mode = "default" if profile.credential_source is None else "explicit"
+            
             profile_dict = {
                 "name": profile.name,
                 "base_url": profile.base_url,
-                "auth_mode": profile.auth_mode,
+                "auth_mode": auth_mode,
                 "verify_ssl": profile.verify_ssl,
                 "output_format": profile.output_format,
-                "label_cache": profile.label_cache,
-                "label_expiry": profile.label_expiry,
+                "label_cache": profile.use_label_cache,
+                "label_expiry": profile.label_cache_expiry_minutes,
                 "language": profile.language,
             }
 
-            # Only show auth details if they exist
-            if profile.client_id:
-                profile_dict["client_id"] = profile.client_id
-            if profile.tenant_id:
-                profile_dict["tenant_id"] = profile.tenant_id
+            # Only show credential source info if it exists
+            if profile.credential_source:
+                profile_dict["credential_source"] = profile.credential_source.source_type
 
             output = self.output_formatter.format_output(profile_dict)
             print(output)
@@ -607,14 +610,23 @@ class CLIManager:
                 print(format_error_message(f"Profile already exists: {profile_name}"))
                 return 1
 
+            # Handle legacy credential parameters
+            auth_mode = getattr(args, "auth_mode", "default")
+            client_id = getattr(args, "client_id", None)
+            client_secret = getattr(args, "client_secret", None)
+            tenant_id = getattr(args, "tenant_id", None)
+            
+            # Create credential source from legacy parameters if needed
+            credential_source = None
+            if auth_mode != "default" and all([client_id, client_secret, tenant_id]):
+                from .credential_sources import EnvironmentCredentialSource
+                credential_source = EnvironmentCredentialSource()
+
             # Create new profile
             profile = Profile(
                 name=profile_name,
                 base_url=base_url,
-                auth_mode=getattr(args, "auth_mode", "default"),
-                client_id=getattr(args, "client_id", None),
-                client_secret=getattr(args, "client_secret", None),
-                tenant_id=getattr(args, "tenant_id", None),
+                credential_source=credential_source,
                 verify_ssl=getattr(args, "verify_ssl", True),
                 output_format=getattr(args, "output_format", "table"),
                 use_label_cache=getattr(args, "label_cache", True),

d365fo_client/client.py

@@ -5,6 +5,8 @@ import logging
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
+from d365fo_client.utils import get_default_cache_directory
+
 from .auth import AuthenticationManager
 from .crud import CrudOperations
 from .exceptions import FOClientError
@@ -72,6 +74,7 @@ class FOClient:
         self.metadata_api_ops = MetadataAPIOperations(
             self.session_manager, self.metadata_url, self.label_ops
         )
+     
 
     async def close(self):
         """Close the client session"""
@@ -94,14 +97,15 @@ class FOClient:
         if not self._metadata_initialized and self.config.enable_metadata_cache:
             try:
 
-                cache_dir = Path(self.config.metadata_cache_dir)
+                cache_dir = Path(self.config.metadata_cache_dir or get_default_cache_directory())
 
                 # Initialize metadata cache v2
                 self.metadata_cache = MetadataCacheV2(
                     cache_dir, self.config.base_url, self.metadata_api_ops
                 )
                 # Initialize label operations v2 with cache support
-                self.label_ops.set_label_cache(self.metadata_cache)
+
+                self.label_ops.set_label_cache(self.metadata_cache) 
 
                 await self.metadata_cache.initialize()
 
@@ -349,7 +353,7 @@ class FOClient:
                 return False
 
             # Perform sync using the new sync manager
-            from .models import SyncStrategy
+            from .sync_models import SyncStrategy
 
             strategy = SyncStrategy.FULL if force_refresh else SyncStrategy.INCREMENTAL
 
@@ -922,7 +926,7 @@ class FOClient:
             use_cache_first=use_cache_first,
         )
 
-        return await resolve_labels_generic(entity, self.label_ops)
+        return await resolve_labels_generic(entity, self.label_ops) #type: ignore
 
     async def get_all_public_entities_with_details(
         self, resolve_labels: bool = False, language: str = "en-US"

d365fo_client/config.py

@@ -92,7 +92,7 @@ class ConfigManager:
 
         profile_data = profiles[profile_name]
         try:
-            return Profile.from_dict(profile_name, profile_data)
+            return Profile.create_from_dict(profile_name, profile_data)
         except Exception as e:
             logger.error(f"Error loading profile {profile_name}: {e}")
             return None
@@ -141,7 +141,7 @@ class ConfigManager:
         profiles = {}
         for name, data in self._config_data.get("profiles", {}).items():
             try:
-                profiles[name] = Profile.from_dict(name, data)
+                profiles[name] = Profile.create_from_dict(name, data)
             except Exception as e:
                 logger.error(f"Error loading profile {name}: {e}")
                 continue
@@ -190,15 +190,19 @@ class ConfigManager:
         # Start with defaults
         config_params = {
             "base_url": None,
-            "use_default_credentials": True,
-            "client_id": None,
-            "client_secret": None,
-            "tenant_id": None,
             "verify_ssl": True,
             "use_label_cache": True,
             "label_cache_expiry_minutes": 60,
             "use_cache_first": True,
             "timeout": 60,
+            "credential_source": None,
+        }
+
+        # Temporary variables for legacy credential handling
+        legacy_credentials: Dict[str, Optional[str]] = {
+            "client_id": None,
+            "client_secret": None,
+            "tenant_id": None,
         }
 
         # Apply profile settings if specified
@@ -211,31 +215,36 @@ class ConfigManager:
             profile = self.get_default_profile()
 
         if profile:
+            # Convert profile to client config and extract relevant parameters
+            client_config = profile.to_client_config()
             config_params.update(
                 {
-                    "base_url": profile.base_url,
-                    "client_id": profile.client_id,
-                    "client_secret": profile.client_secret,
-                    "tenant_id": profile.tenant_id,
-                    "verify_ssl": profile.verify_ssl,
-                    "use_label_cache": profile.use_label_cache,
-                    "label_cache_expiry_minutes": profile.label_cache_expiry_minutes,
-                    "use_cache_first": profile.use_cache_first,
-                    "timeout": profile.timeout,
+                    "base_url": client_config.base_url,
+                    "verify_ssl": client_config.verify_ssl,
+                    "use_label_cache": client_config.use_label_cache,
+                    "label_cache_expiry_minutes": client_config.label_cache_expiry_minutes,
+                    "use_cache_first": client_config.use_cache_first,
+                    "timeout": client_config.timeout,
+                    "credential_source": client_config.credential_source,
                 }
             )
 
         # Apply environment variables
         env_mappings = {
             "D365FO_BASE_URL": "base_url",
-            "D365FO_CLIENT_ID": "client_id",
-            "D365FO_CLIENT_SECRET": "client_secret",
-            "D365FO_TENANT_ID": "tenant_id",
             "D365FO_VERIFY_SSL": "verify_ssl",
             "D365FO_LABEL_CACHE": "use_label_cache",
             "D365FO_LABEL_EXPIRY": "label_cache_expiry_minutes",
             "D365FO_USE_CACHE_FIRST": "use_cache_first",
             "D365FO_TIMEOUT": "timeout",
+            "D365FO_CACHE_DIR": "metadata_cache_dir",
+        }
+
+        # Environment variables for legacy credentials
+        legacy_env_mappings = {
+            "D365FO_CLIENT_ID": "client_id",
+            "D365FO_CLIENT_SECRET": "client_secret",
+            "D365FO_TENANT_ID": "tenant_id",
         }
 
         for env_var, param_name in env_mappings.items():
@@ -258,12 +267,15 @@ class ConfigManager:
                 else:
                     config_params[param_name] = env_value
 
+        # Handle legacy credential environment variables
+        for env_var, param_name in legacy_env_mappings.items():
+            env_value = os.getenv(env_var)
+            if env_value:
+                legacy_credentials[param_name] = env_value
+
         # Apply command line arguments (highest precedence)
         arg_mappings = {
             "base_url": "base_url",
-            "client_id": "client_id",
-            "client_secret": "client_secret",
-            "tenant_id": "tenant_id",
             "verify_ssl": "verify_ssl",
             "label_cache": "use_label_cache",
             "label_expiry": "label_cache_expiry_minutes",
@@ -271,20 +283,30 @@ class ConfigManager:
             "timeout": "timeout",
         }
 
+        # Legacy credential CLI args
+        legacy_arg_mappings = {
+            "client_id": "client_id",
+            "client_secret": "client_secret",
+            "tenant_id": "tenant_id",
+        }
+
         for arg_name, param_name in arg_mappings.items():
             arg_value = getattr(args, arg_name, None)
             if arg_value is not None:
                 config_params[param_name] = arg_value
 
-        # Determine authentication mode
-        if any(
-            [
-                config_params["client_id"],
-                config_params["client_secret"],
-                config_params["tenant_id"],
-            ]
-        ):
-            config_params["use_default_credentials"] = False
+        # Handle legacy credential CLI arguments
+        for arg_name, param_name in legacy_arg_mappings.items():
+            arg_value = getattr(args, arg_name, None)
+            if arg_value is not None:
+                legacy_credentials[param_name] = arg_value
+
+        # Create credential source from legacy credentials if provided
+        if any(legacy_credentials.values()) and config_params["credential_source"] is None:
+            # Check if we have all required credentials
+            if all(legacy_credentials.values()):
+                from .credential_sources import EnvironmentCredentialSource
+                config_params["credential_source"] = EnvironmentCredentialSource()
 
         return FOClientConfig(**config_params)
 

d365fo_client/credential_sources.py

@@ -210,6 +210,8 @@ class EnvironmentCredentialProvider(CredentialProvider):
             raise ValueError(f"Missing required environment variables: {', '.join(missing_vars)}")
         
         logger.debug(f"Retrieved credentials from environment variables: {source.client_id_var}, {source.client_secret_var}, {source.tenant_id_var}")
+        assert client_id and client_secret and tenant_id  # For type checker
+
         return client_id, client_secret, tenant_id
 
 
@@ -252,6 +254,7 @@ class KeyVaultCredentialProvider(CredentialProvider):
                 raise ValueError("One or more secrets retrieved from Key Vault are empty")
             
             logger.debug(f"Retrieved credentials from Key Vault: {source.vault_url}")
+            assert client_id and client_secret and tenant_id  # For type checker
             return client_id, client_secret, tenant_id
             
         except Exception as e:
@@ -282,6 +285,8 @@ class KeyVaultCredentialProvider(CredentialProvider):
             if not all([source.keyvault_client_id, source.keyvault_client_secret, source.keyvault_tenant_id]):
                 raise ValueError("Key Vault client_secret authentication requires keyvault_client_id, keyvault_client_secret, and keyvault_tenant_id")
             
+            assert source.keyvault_client_id and source.keyvault_client_secret and source.keyvault_tenant_id  # For type checker
+            
             credential = ClientSecretCredential(
                 tenant_id=source.keyvault_tenant_id,
                 client_id=source.keyvault_client_id,

d365fo_client/main.py

@@ -12,7 +12,7 @@ async def example_usage():
     """Example usage of the F&O client with label functionality"""
     config = FOClientConfig(
         base_url="https://usnconeboxax1aos.cloud.onebox.dynamics.com",
-        use_default_credentials=True,
+
         verify_ssl=False,
         use_label_cache=True,
         label_cache_expiry_minutes=60,

d365fo_client/mcp/__init__.py

@@ -8,9 +8,11 @@ integration workflows through standardized MCP protocol.
 """
 
 from .client_manager import D365FOClientManager
+from .fastmcp_server import FastD365FOMCPServer
 from .server import D365FOMCPServer
 
 __all__ = [
-    "D365FOMCPServer",
+    "D365FOMCPServer",           # Legacy MCP server (backward compatibility)
+    "FastD365FOMCPServer",       # New FastMCP server with multi-transport support
     "D365FOClientManager",
 ]

d365fo_client/mcp/auth_server/__init__.py

@@ -0,0 +1,5 @@
+"""Server components for the D365FO MCP server."""
+
+from .auth.providers.azure import AzureProvider
+
+__all__ = ["AzureProvider"]

d365fo_client/mcp/auth_server/auth/__init__.py

@@ -0,0 +1,30 @@
+from .auth import (
+    OAuthProvider,
+    TokenVerifier,
+    RemoteAuthProvider,
+    AccessToken,
+    AuthProvider,
+)
+from .providers.jwt import JWTVerifier, StaticTokenVerifier
+from .oauth_proxy import OAuthProxy
+
+
+__all__ = [
+    "AuthProvider",
+    "OAuthProvider",
+    "TokenVerifier",
+    "JWTVerifier",
+    "StaticTokenVerifier",
+    "RemoteAuthProvider",
+    "AccessToken",
+    "OAuthProxy",
+]
+
+
+def __getattr__(name: str):
+    # Defer import because it raises a deprecation warning
+    if name == "BearerAuthProvider":
+        from .providers.bearer import BearerAuthProvider
+
+        return BearerAuthProvider
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")