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

d365fo_client/__init__.py

@@ -174,55 +174,13 @@ from .main import main
 # MCP Server
 from .mcp import D365FOClientManager, D365FOMCPServer
 
-# Legacy Metadata Cache (deprecated - use metadata_v2)
-# REMOVED: Legacy classes have been replaced with V2 implementations
-# from .metadata_cache import MetadataCache, MetadataSearchEngine
-
 # V2 Metadata Cache (recommended - now the only implementation)
 from .metadata_v2 import MetadataCacheV2, VersionAwareSearchEngine
 
 # Provide backward compatibility with immediate import errors
-import warnings
-
-class _DeprecatedMetadataCache:
-    """Deprecated placeholder for MetadataCache - raises error on any access"""
-    def __init__(self, *args, **kwargs):
-        warnings.warn(
-            "MetadataCache is deprecated and has been removed. "
-            "Use MetadataCacheV2 from d365fo_client.metadata_v2 instead.",
-            DeprecationWarning,
-            stacklevel=2
-        )
-        raise ImportError(
-            "MetadataCache has been removed. Use MetadataCacheV2 from d365fo_client.metadata_v2 instead."
-        )
-    
-    def __getattr__(self, name):
-        raise ImportError(
-            "MetadataCache has been removed. Use MetadataCacheV2 from d365fo_client.metadata_v2 instead."
-        )
-
-class _DeprecatedMetadataSearchEngine:
-    """Deprecated placeholder for MetadataSearchEngine - raises error on any access"""
-    def __init__(self, *args, **kwargs):
-        warnings.warn(
-            "MetadataSearchEngine is deprecated and has been removed. "
-            "Use VersionAwareSearchEngine from d365fo_client.metadata_v2 instead.",
-            DeprecationWarning,
-            stacklevel=2
-        )
-        raise ImportError(
-            "MetadataSearchEngine has been removed. Use VersionAwareSearchEngine from d365fo_client.metadata_v2 instead."
-        )
-    
-    def __getattr__(self, name):
-        raise ImportError(
-            "MetadataSearchEngine has been removed. Use VersionAwareSearchEngine from d365fo_client.metadata_v2 instead."
-        )
-
-# Create deprecated placeholder classes
-MetadataCache = _DeprecatedMetadataCache
-MetadataSearchEngine = _DeprecatedMetadataSearchEngine
+
+
+
 from .models import (
     ActionInfo,
     DataEntityInfo,
@@ -255,9 +213,7 @@ __all__ = [
     # Main client
     "FOClient",
     "create_client",
-    # Legacy caching (deprecated placeholders - raise errors when used)
-    "MetadataCache", 
-    "MetadataSearchEngine",
+
     # V2 caching (now the primary implementation)
     "MetadataCacheV2", 
     "VersionAwareSearchEngine",

d365fo_client/auth.py

@@ -5,6 +5,7 @@ from typing import Optional
 
 from azure.identity import ClientSecretCredential, DefaultAzureCredential
 
+from .credential_sources import CredentialManager, CredentialSource
 from .models import FOClientConfig
 
 
@@ -20,25 +21,46 @@ class AuthenticationManager:
         self.config = config
         self._token = None
         self._token_expires = None
-        self.credential = self._setup_credentials()
-
-    def _setup_credentials(self):
-        """Setup authentication credentials"""
-        if self.config.use_default_credentials:
-            return DefaultAzureCredential()
-        elif (
+        self._credential_manager = CredentialManager()
+        self.credential = 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)
+        
+        if credential_source is not None:
+            # Use credential source to get credentials
+            try:
+                client_id, client_secret, tenant_id = await self._credential_manager.get_credentials(credential_source)
+                self.credential = ClientSecretCredential(
+                    tenant_id=tenant_id,
+                    client_id=client_id,
+                    client_secret=client_secret,
+                )
+                return
+            except Exception as e:
+                raise ValueError(f"Failed to setup credentials from source: {e}")
+        
+        
+        # Fallback to existing logic for backward compatibility
+  
+        if (
             self.config.client_id
             and self.config.client_secret
             and self.config.tenant_id
         ):
-            return ClientSecretCredential(
+            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 or client credentials"
+                "Must provide either use_default_credentials=True, client credentials, or credential_source"
             )
 
     async def get_token(self) -> str:
@@ -51,6 +73,10 @@ class AuthenticationManager:
         if self._is_localhost():
             return "mock-token-for-localhost"
 
+        # Initialize credentials if not already set
+        if self.credential is None:
+            await self._setup_credentials()
+
         if (
             self._token
             and self._token_expires
@@ -91,3 +117,16 @@ class AuthenticationManager:
         """Invalidate cached token to force refresh"""
         self._token = None
         self._token_expires = None
+
+    async def invalidate_credentials(self):
+        """Invalidate cached credentials and token to force full refresh"""
+        self.invalidate_token()
+        self.credential = None
+        if hasattr(self, '_credential_manager'):
+            self._credential_manager.clear_cache()
+
+    def get_credential_cache_stats(self) -> dict:
+        """Get credential cache statistics for debugging"""
+        if hasattr(self, '_credential_manager'):
+            return self._credential_manager.get_cache_stats()
+        return {"total_cached": 0, "expired": 0, "active": 0}

d365fo_client/client.py

@@ -11,6 +11,7 @@ from .exceptions import FOClientError
 from .labels import LabelOperations, resolve_labels_generic
 from .metadata_api import MetadataAPIOperations
 from .metadata_v2 import MetadataCacheV2, SmartSyncManagerV2
+from .metadata_v2.sync_session_manager import SyncSessionManager
 from .models import (
     ActionInfo,
     DataEntityInfo,
@@ -58,6 +59,7 @@ class FOClient:
         # Initialize new metadata cache and sync components
         self.metadata_cache = None
         self.sync_manager = None
+        self._sync_session_manager = None
         self._metadata_initialized = False
         self._background_sync_task = None
 
@@ -83,6 +85,10 @@ class FOClient:
 
         await self.session_manager.close()
 
+    
+    async def initialize_metadata(self):
+        await self._ensure_metadata_initialized()
+
     async def _ensure_metadata_initialized(self):
         """Ensure metadata cache and sync manager are initialized"""
         if not self._metadata_initialized and self.config.enable_metadata_cache:
@@ -104,6 +110,9 @@ class FOClient:
                     self.metadata_cache, self.metadata_api_ops
                 )
 
+                # Initialize sync message with session
+                self._sync_session_manager = SyncSessionManager(self.metadata_cache, self.metadata_api_ops)
+
                 self._metadata_initialized = True
                 self.logger.debug("Metadata cache v2 with label caching initialized")
 
@@ -113,23 +122,27 @@ class FOClient:
                 self.config.enable_metadata_cache = False
 
     async def _trigger_background_sync_if_needed(self):
-        """Trigger background sync if metadata is stale or missing"""
+        """Trigger background sync if metadata is stale or missing (non-blocking)"""
         if not self.config.enable_metadata_cache or not self._metadata_initialized:
             return
 
+        # Don't trigger sync if already running
+        if self._is_background_sync_running():
+            return
+
         try:
             # Check if we need to sync using the new v2 API
+            # This should be a quick check, not actual sync work
             sync_needed, global_version_id = (
                 await self.metadata_cache.check_version_and_sync(self.metadata_api_ops)
             )
 
             if sync_needed and global_version_id:
-                # Only start sync if not already running
-                if not self._background_sync_task or self._background_sync_task.done():
-                    self._background_sync_task = asyncio.create_task(
-                        self._background_sync_worker(global_version_id)
-                    )
-                    self.logger.debug("Background metadata sync triggered")
+                # Start sync in background without awaiting it
+                self._background_sync_task = asyncio.create_task(
+                    self._background_sync_worker(global_version_id)
+                )
+                self.logger.debug("Background metadata sync triggered")
         except Exception as e:
             self.logger.warning(f"Failed to check sync status: {e}")
 
@@ -140,18 +153,9 @@ class FOClient:
                 f"Starting background metadata sync for version {global_version_id}"
             )
 
-            # Use self as the fo_client for sync - SmartSyncManagerV2 expects a client with metadata API operations
-            result = await self.sync_manager.sync_metadata(global_version_id)
-
-            if result.success:
-                self.logger.info(
-                    f"Background sync completed: "
-                    f"{result.entity_count} entities, "
-                    f"{result.enumeration_count} enumerations, "
-                    f"{result.duration_ms:.2f}ms"
-                )
-            else:
-                self.logger.warning(f"Background sync failed: {result.error}")
+ 
+            self.sync_session_manager.start_sync_session(global_version_id=global_version_id,initiated_by="background_task")
+            
 
         except Exception as e:
             self.logger.error(f"Background sync error: {e}")
@@ -168,6 +172,27 @@ class FOClient:
             and not self._background_sync_task.done()
         )
 
+    @property
+    def sync_session_manager(self) -> SyncSessionManager:
+        """Get sync session manager (lazy initialization).
+        
+        Returns:
+            SyncSessionManager instance for enhanced sync progress tracking
+            
+        Raises:
+            RuntimeError: If metadata cache is not initialized
+        """
+        if self._sync_session_manager is None:
+            if not self.metadata_cache:
+                raise RuntimeError("Metadata cache must be initialized before accessing sync session manager")
+            
+            self._sync_session_manager = SyncSessionManager(
+                cache=self.metadata_cache,
+                metadata_api=self.metadata_api_ops
+            )
+        
+        return self._sync_session_manager
+
     async def _get_from_cache_first(
         self,
         cache_method,
@@ -222,7 +247,8 @@ class FOClient:
 
             # If cache returns empty result, trigger sync and try fallback
             if not result or (isinstance(result, list) and len(result) == 0):
-                await self._trigger_background_sync_if_needed()
+                # Trigger background sync without awaiting (fire-and-forget)
+                asyncio.create_task(self._trigger_background_sync_if_needed())
                 return (
                     await fallback_method(*args, **kwargs)
                     if asyncio.iscoroutinefunction(fallback_method)
@@ -233,8 +259,8 @@ class FOClient:
 
         except Exception as e:
             self.logger.warning(f"Cache lookup failed, using fallback: {e}")
-            # Trigger sync if cache failed
-            await self._trigger_background_sync_if_needed()
+            # Trigger sync if cache failed (fire-and-forget)
+            asyncio.create_task(self._trigger_background_sync_if_needed())
             return (
                 await fallback_method(*args, **kwargs)
                 if asyncio.iscoroutinefunction(fallback_method)
@@ -682,17 +708,16 @@ class FOClient:
 
     async def get_data_entities(
         self, options: Optional[QueryOptions] = None
-    ) -> List[DataEntityInfo]:
-        """Get data entities - updated to return list for v2 sync compatibility
+    ) -> Dict[str, Any]:
+        """Get data entities from DataEntities metadata endpoint
 
         Args:
-            options: OData query options (ignored for now)
+            options: OData query options
 
         Returns:
-            List of DataEntityInfo objects
+            Response containing data entities
         """
-        # For sync manager compatibility, return list of DataEntityInfo objects
-        return await self.metadata_api_ops.search_data_entities("")  # Get all entities
+        return await self.metadata_api_ops.get_data_entities(options)
 
     async def get_data_entities_raw(
         self, options: Optional[QueryOptions] = None
@@ -929,7 +954,7 @@ class FOClient:
         Returns:
             Response containing public enumerations
         """
-        self._ensure_metadata_initialized()
+        await self._ensure_metadata_initialized()
 
         return await self.metadata_api_ops.get_public_enumerations(options)
 
@@ -1037,29 +1062,44 @@ class FOClient:
             try:
                 import asyncio
 
-                # Get the current event loop or create a new one
+                # Always check if we're in an async context first
                 try:
-                    loop = asyncio.get_event_loop()
-                except RuntimeError:
-                    loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(loop)
-
-                if loop.is_running():
-                    # If we're in an async context, we can't run async code synchronously
+                    loop = asyncio.get_running_loop()
+                    # We're in an async context, can't run async code synchronously
                     return {
                         "enabled": True,
                         "cache_type": "metadata_v2",
                         "message": "Label caching enabled with v2 cache (statistics available via async method)",
                     }
-                else:
-                    # If we're not in an async context, we can get the statistics
-                    stats = loop.run_until_complete(
-                        self.metadata_cache.get_label_cache_statistics()
-                    )
+                except RuntimeError:
+                    # No running loop, we can safely create one
+                    pass
+
+                # Create a new event loop for synchronous execution
+                try:
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    try:
+                        stats = loop.run_until_complete(
+                            self.metadata_cache.get_label_cache_statistics()
+                        )
+                        return {
+                            "enabled": True,
+                            "cache_type": "metadata_v2",
+                            "statistics": stats,
+                        }
+                    finally:
+                        loop.close()
+                        # Remove the loop to clean up
+                        try:
+                            asyncio.set_event_loop(None)
+                        except:
+                            pass
+                except Exception as e:
                     return {
                         "enabled": True,
                         "cache_type": "metadata_v2",
-                        "statistics": stats,
+                        "error": f"Error getting statistics: {e}",
                     }
             except Exception as e:
                 return {
@@ -1168,7 +1208,7 @@ class FOClient:
                     "advanced_cache_enabled": True,
                     "cache_v2_enabled": True,
                     "cache_initialized": self._metadata_initialized,
-                    "sync_manager_available": self.sync_manager is not None,
+                    "sync_manager_available": self.sync_manager is not None or self._sync_session_manager is not None,
                     "background_sync_running": self._is_background_sync_running(),
                     "statistics": stats,
                 }