d365fo-client 0.1.0__tar.gz → 0.2.2__tar.gz

{d365fo_client-0.1.0/src/d365fo_client.egg-info → d365fo_client-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d365fo-client
-Version: 0.1.0
+Version: 0.2.2
 Summary: Microsoft Dynamics 365 Finance & Operations client
 Author-email: Muhammad Afzaal <mo@thedataguy.pro>
 License-Expression: MIT
@@ -911,6 +911,8 @@ Add to your VS Code `mcp.json` for GitHub Copilot with MCP:
       "type": "stdio",
       "command": "uvx",
       "args": [
+        "--from",
+        "d365fo-client",
         "d365fo-mcp-server"
       ],
       "env": {
@@ -932,6 +934,8 @@ For environments requiring service principal authentication:
       "type": "stdio", 
       "command": "uvx",
       "args": [
+        "--from",
+        "d365fo-client",
         "d365fo-mcp-server"
       ],
       "env": {

{d365fo_client-0.1.0 → d365fo_client-0.2.2}/README.md

@@ -870,6 +870,8 @@ Add to your VS Code `mcp.json` for GitHub Copilot with MCP:
       "type": "stdio",
       "command": "uvx",
       "args": [
+        "--from",
+        "d365fo-client",
         "d365fo-mcp-server"
       ],
       "env": {
@@ -891,6 +893,8 @@ For environments requiring service principal authentication:
       "type": "stdio", 
       "command": "uvx",
       "args": [
+        "--from",
+        "d365fo-client",
         "d365fo-mcp-server"
       ],
       "env": {

{d365fo_client-0.1.0 → d365fo_client-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "d365fo-client"
-version = "0.1.0"
+version = "0.2.2"
 description = "Microsoft Dynamics 365 Finance & Operations client"
 readme = "README.md"
 license = "MIT"

{d365fo_client-0.1.0 → d365fo_client-0.2.2}/src/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-0.1.0 → d365fo_client-0.2.2}/src/d365fo_client/client.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import logging
-import os
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
@@ -114,23 +113,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}")
 
@@ -158,6 +161,17 @@ class FOClient:
             self.logger.error(f"Background sync error: {e}")
             # Don't re-raise to avoid breaking the background task
 
+    def _is_background_sync_running(self) -> bool:
+        """Check if background sync task is currently running
+
+        Returns:
+            True if background sync is actively running, False otherwise
+        """
+        return (
+            self._background_sync_task is not None
+            and not self._background_sync_task.done()
+        )
+
     async def _get_from_cache_first(
         self,
         cache_method,
@@ -179,8 +193,12 @@ class FOClient:
         if use_cache_first is None:
             use_cache_first = self.config.use_cache_first
 
-        # If cache-first is disabled, go straight to fallback
-        if not use_cache_first or not self.config.enable_metadata_cache:
+        # If cache-first is disabled, metadata cache is disabled, or background sync is running, go straight to fallback
+        if (
+            not use_cache_first
+            or not self.config.enable_metadata_cache
+            or self._is_background_sync_running()
+        ):
             return (
                 await fallback_method(*args, **kwargs)
                 if asyncio.iscoroutinefunction(fallback_method)
@@ -208,7 +226,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)
@@ -219,8 +238,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)
@@ -375,7 +394,7 @@ class FOClient:
         return await self._get_from_cache_first(
             cache_search,
             fallback_search,
-            use_cache_first=use_cache_first or self.config.use_cache_first,
+            use_cache_first=use_cache_first,
         )
 
     async def get_entity_info(
@@ -415,20 +434,34 @@ class FOClient:
         await self._ensure_metadata_initialized()
 
         async def cache_search():
-            # TODO: v2 cache doesn't have action search yet - will be implemented in future phase
-            # For now, always return empty to force fallback to API
-            return []
+            # Use the v2 cache action search functionality
+            if not self.metadata_cache:
+                return []
+
+            # Convert regex pattern to SQL LIKE pattern for cache
+            cache_pattern = None
+            if pattern:
+                # Convert simple regex to SQL LIKE pattern
+                cache_pattern = pattern.replace(".*", "%").replace(".", "_")
+                if not cache_pattern.startswith("%") and not cache_pattern.endswith("%"):
+                    cache_pattern = f"%{cache_pattern}%"
+
+            return await self.metadata_cache.search_actions(
+                pattern=cache_pattern,
+                entity_name=entity_name,
+                binding_kind=binding_kind,
+            )
 
         async def fallback_search():
-            # Actions are not directly available through metadata API
-            # They are part of entity definitions
-            # Return empty list for backward compatibility
-            return []
+            # Use the new metadata API operations for action search
+            return await self.metadata_api_ops.search_actions(
+                pattern, entity_name, binding_kind
+            )
 
         actions = await self._get_from_cache_first(
             cache_search,
             fallback_search,
-            use_cache_first=use_cache_first or self.config.use_cache_first,
+            use_cache_first=use_cache_first,
         )
 
         return await resolve_labels_generic(actions, self.label_ops)
@@ -451,20 +484,25 @@ class FOClient:
         """
 
         async def cache_lookup():
-            # TODO: v2 cache doesn't have action lookup yet - will be implemented in future phase
-            # For now, always return None to force fallback to API
-            return None
+            # Use the v2 cache action lookup functionality
+            if not self.metadata_cache:
+                return None
+
+            return await self.metadata_cache.get_action_info(
+                action_name=action_name,
+                entity_name=entity_name,
+            )
 
         async def fallback_lookup():
-            # Actions are not directly available through metadata API
-            # They are part of entity definitions
-            # Return None for backward compatibility
-            return None
+            # Use the new metadata API operations for action lookup
+            return await self.metadata_api_ops.get_action_info(action_name, entity_name)
 
-        return await self._get_from_cache_first(
+        action = await self._get_from_cache_first(
             cache_lookup, fallback_lookup, use_cache_first=use_cache_first
         )
 
+        return await resolve_labels_generic(action, self.label_ops) if action else None
+
     # CRUD Operations
 
     async def get_entities(
@@ -736,7 +774,7 @@ class FOClient:
         entities = await self._get_from_cache_first(
             cache_search,
             fallback_search,
-            use_cache_first=use_cache_first or self.config.use_cache_first,
+            use_cache_first=use_cache_first,
         )
 
         if self.metadata_cache:
@@ -861,7 +899,7 @@ class FOClient:
         entity = await self._get_from_cache_first(
             cache_lookup,
             fallback_lookup,
-            use_cache_first=use_cache_first or self.config.use_cache_first,
+            use_cache_first=use_cache_first,
         )
 
         return await resolve_labels_generic(entity, self.label_ops)
@@ -924,7 +962,7 @@ class FOClient:
         enums = await self._get_from_cache_first(
             cache_search,
             fallback_search,
-            use_cache_first=use_cache_first or self.config.use_cache_first,
+            use_cache_first=use_cache_first,
         )
 
         return await resolve_labels_generic(enums, self.label_ops)
@@ -961,7 +999,7 @@ class FOClient:
         enum = await self._get_from_cache_first(
             cache_lookup,
             fallback_lookup,
-            use_cache_first=use_cache_first or self.config.use_cache_first,
+            use_cache_first=use_cache_first,
         )
         return await resolve_labels_generic(enum, self.label_ops) if enum else None
 
@@ -1004,29 +1042,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 {
@@ -1136,14 +1189,7 @@ class FOClient:
                     "cache_v2_enabled": True,
                     "cache_initialized": self._metadata_initialized,
                     "sync_manager_available": self.sync_manager is not None,
-                    "background_sync_running": (
-                        (
-                            self._background_sync_task
-                            and not self._background_sync_task.done()
-                        )
-                        if self._background_sync_task
-                        else False
-                    ),
+                    "background_sync_running": self._is_background_sync_running(),
                     "statistics": stats,
                 }
                 info.update(cache_info)

{d365fo_client-0.1.0 → d365fo_client-0.2.2}/src/d365fo_client/config.py

@@ -69,6 +69,14 @@ class ConfigManager:
         except Exception as e:
             print(f"Error saving config file {self.config_path}: {e}")
 
+    def reload_config(self) -> None:
+        """Reload configuration from file.
+        
+        This is useful when the config file has been modified externally
+        or by another instance of the ConfigManager.
+        """
+        self._config_data = self._load_config()
+
     def get_profile(self, profile_name: str) -> Optional[Profile]:
         """Get a specific configuration profile.
 

{d365fo_client-0.1.0 → d365fo_client-0.2.2}/src/d365fo_client/labels.py

@@ -401,14 +401,14 @@ async def _resolve_labels_batch(
         # Log individual results at debug level
         for label_id in label_ids:
             if label_id in label_texts:
-                logger.debug(f"✅ Resolved '{label_id}' -> '{label_texts[label_id]}'")
+                logger.debug(f"[OK] Resolved '{label_id}' -> '{label_texts[label_id]}'")
             else:
-                logger.debug(f"❌ No text found for label ID '{label_id}'")
+                logger.debug(f"[MISS] No text found for label ID '{label_id}'")
 
         return label_texts
 
     except Exception as e:
-        logger.warning(f"❌ Error in batch label resolution: {e}")
+        logger.warning(f"[ERROR] Error in batch label resolution: {e}")
         return {}
 
 

{d365fo_client-0.1.0 → d365fo_client-0.2.2}/src/d365fo_client/main.py

@@ -20,26 +20,26 @@ async def example_usage():
 
     async with FOClient(config) as client:
         # Test connections
-        print("🔗 Testing connections...")
+        print("[INFO] Testing connections...")
         if await client.test_connection():
-            print("✅ Connected to F&O OData successfully")
+            print("[OK] Connected to F&O OData successfully")
 
         if await client.test_metadata_connection():
-            print("✅ Connected to F&O Metadata API successfully")
+            print("[OK] Connected to F&O Metadata API successfully")
 
         # Download metadata
         print("\n📥 Downloading metadata...")
         await client.download_metadata()
 
         # Search entities
-        print("\n🔍 Searching entities...")
+        print("\n[SEARCH] Searching entities...")
         customer_entities = await client.search_entities("customer")
         print(f"Found {len(customer_entities)} customer-related entities")
         for entity in customer_entities[:5]:  # Show first 5
             print(f"  - {entity}")
 
         # Get entity info with labels
-        print("\n📊 Getting entity information...")
+        print("\n[INFO] Getting entity information...")
         customers_info = await client.get_entity_info_with_labels("Customer")
         if customers_info:
             print(f"Customers entity: {customers_info.name}")
@@ -128,7 +128,7 @@ async def example_usage():
         print("\n🆕 New Metadata APIs:")
 
         # Data Entities API
-        print("\n📊 Data Entities API:")
+        print("\n[API] Data Entities API:")
         data_entities = await client.search_data_entities(
             "customer", entity_category="Master"
         )

{d365fo_client-0.1.0 → d365fo_client-0.2.2}/src/d365fo_client/mcp/client_manager.py

@@ -20,17 +20,18 @@ logger = logging.getLogger(__name__)
 class D365FOClientManager:
     """Manages D365FO client instances and connection pooling."""
 
-    def __init__(self, config: dict):
+    def __init__(self, config: dict, profile_manager: Optional[ProfileManager] = None):
         """Initialize the client manager.
 
         Args:
             config: Configuration dictionary with client settings
+            profile_manager: Optional shared ProfileManager instance
         """
         self.config = config
         self._client_pool: Dict[str, FOClient] = {}
         self._session_lock = asyncio.Lock()
         self._last_health_check: Optional[datetime] = None
-        self.profile_manager = ProfileManager()
+        self.profile_manager = profile_manager or ProfileManager()
 
     async def get_client(self, profile: str = "default") -> FOClient:
         """Get or create a client for the specified profile.
@@ -144,6 +145,33 @@ class D365FOClientManager:
                         )
                 self._client_pool.clear()
 
+    async def refresh_profile(self, profile: str):
+        """Refresh a specific profile by clearing its cached client.
+        
+        This forces the client manager to recreate the client with
+        updated profile configuration on next access.
+        
+        Args:
+            profile: Profile name to refresh
+        """
+        logger.info(f"Refreshing profile: {profile}")
+        # Reload configuration to see any recent changes
+        self.profile_manager.reload_config()
+        # Clear the cached client for this profile
+        await self.cleanup(profile)
+
+    async def refresh_all_profiles(self):
+        """Refresh all profiles by clearing the entire client pool.
+        
+        This forces the client manager to recreate all clients with
+        updated profile configurations on next access.
+        """
+        logger.info("Refreshing all profiles")
+        # Reload configuration to see any recent changes
+        self.profile_manager.reload_config()
+        # Clear all cached clients
+        await self.cleanup()
+
     def _build_client_config(self, profile: str) -> FOClientConfig:
         """Build FOClientConfig from profile configuration.
 

{d365fo_client-0.1.0 → d365fo_client-0.2.2}/src/d365fo_client/mcp/main.py

@@ -6,8 +6,9 @@ import logging
 import os
 import sys
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
+from d365fo_client import __version__
 from d365fo_client.mcp import D365FOMCPServer
 
 
@@ -23,6 +24,11 @@ def setup_logging(level: str = "INFO") -> None:
     log_dir = Path.home() / ".d365fo-mcp" / "logs"
     log_dir.mkdir(parents=True, exist_ok=True)
 
+    # Clear existing handlers to avoid duplicate logging
+    root_logger = logging.getLogger()
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+
     # Configure logging
     logging.basicConfig(
         level=log_level,
@@ -31,14 +37,15 @@ def setup_logging(level: str = "INFO") -> None:
             logging.FileHandler(log_dir / "mcp-server.log"),
             logging.StreamHandler(sys.stderr),
         ],
+        force=True,  # Force reconfiguration even if logging is already configured
     )
 
 
-def load_config() -> Optional[Dict[str, Any]]:
+def load_config() -> Dict[str, Any]:
     """Load configuration from environment and config files.
 
     Returns:
-        Configuration dictionary or None for defaults
+        Configuration dictionary
     """
     config = {}
 
@@ -56,16 +63,22 @@ def load_config() -> Optional[Dict[str, Any]]:
     if tenant_id := os.getenv("AZURE_TENANT_ID"):
         config.setdefault("default_environment", {})["tenant_id"] = tenant_id
 
-    # Logging level
-    log_level = os.getenv("D365FO_LOG_LEVEL", "INFO")
-    setup_logging(log_level)
+    # Check if D365FO_BASE_URL is configured for startup behavior
+    config["has_base_url"] = bool(os.getenv("D365FO_BASE_URL"))
 
-    return config if config else None
+    return config
 
 
 async def async_main() -> None:
     """Async main entry point for the MCP server."""
     try:
+        # Set up logging first based on environment variable
+        log_level = os.getenv("D365FO_LOG_LEVEL", "INFO")
+        setup_logging(log_level)
+        
+        # Print server version at startup
+        logging.info(f"D365FO MCP Server v{__version__}")
+        
         # Load configuration
         config = load_config()
 

{d365fo_client-0.1.0 → d365fo_client-0.2.2}/src/d365fo_client/mcp/models.py

@@ -2,7 +2,7 @@
 
 from dataclasses import dataclass
 from datetime import datetime
-from enum import Enum
+from enum import StrEnum
 from typing import Any, Dict, List, Optional, Union
 
 # Resource Models
@@ -37,7 +37,7 @@ class EntityResourceContent:
     last_updated: Optional[str] = None
 
 
-class MetadataType(Enum):
+class MetadataType(StrEnum):
     ENTITIES = "entities"
     ACTIONS = "actions"
     ENUMERATIONS = "enumerations"