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

{d365fo_client-0.2.1/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.2.1
+Version: 0.2.2
 Summary: Microsoft Dynamics 365 Finance & Operations client
 Author-email: Muhammad Afzaal <mo@thedataguy.pro>
 License-Expression: MIT

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

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

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

@@ -113,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}")
 
@@ -222,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)
@@ -233,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)
@@ -1037,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 {

{d365fo_client-0.2.1 → 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"

{d365fo_client-0.2.1 → d365fo_client-0.2.2}/src/d365fo_client/mcp/tools/connection_tools.py

@@ -8,6 +8,7 @@ from typing import List
 from mcp import Tool
 from mcp.types import TextContent
 
+from ... import __version__
 from ..client_manager import D365FOClientManager
 
 logger = logging.getLogger(__name__)
@@ -95,6 +96,7 @@ class ConnectionTools:
             response = {
                 "success": success,
                 "profile": profile,
+                "clientVersion": __version__,
                 "endpoints": {
                     "data": success,
                     "metadata": success,  # Simplification for now
@@ -113,6 +115,7 @@ class ConnectionTools:
             error_response = {
                 "success": False,
                 "profile": arguments.get("profile", "default"),
+                "clientVersion": __version__,
                 "endpoints": {"data": False, "metadata": False},
                 "responseTime": 0.0,
                 "error": str(e),
@@ -124,6 +127,7 @@ class ConnectionTools:
             error_response = {
                 "success": False,
                 "profile": arguments.get("profile", "default"),
+                "clientVersion": __version__,
                 "endpoints": {"data": False, "metadata": False},
                 "responseTime": 0.0,
                 "error": str(e),
@@ -146,6 +150,7 @@ class ConnectionTools:
             # Format response according to specification with enhanced metadata info
             response = {
                 "baseUrl": env_info["base_url"],
+                "clientVersion": __version__,
                 "versions": env_info["versions"],
                 "connectivity": env_info["connectivity"],
                 "metadataInfo": env_info["metadata_info"],
@@ -160,6 +165,7 @@ class ConnectionTools:
             )
             error_response = {
                 "error": str(e),
+                "clientVersion": __version__,
                 "tool": "d365fo_get_environment_info",
                 "arguments": arguments,
                 "suggestion": "Please create a profile or set a default profile using the profile management tools.",
@@ -169,6 +175,7 @@ class ConnectionTools:
             logger.error(f"Get environment info failed: {e}")
             error_response = {
                 "error": str(e),
+                "clientVersion": __version__,
                 "tool": "d365fo_get_environment_info",
                 "arguments": arguments,
             }

{d365fo_client-0.2.1 → d365fo_client-0.2.2}/src/d365fo_client/metadata_api.py

@@ -940,7 +940,7 @@ class MetadataAPIOperations:
                         continue
 
                     # Filter by binding kind
-                    if binding_kind and action.binding_kind.value != binding_kind:
+                    if binding_kind and action.binding_kind != binding_kind:
                         continue
 
                     # Create ActionInfo with entity context

{d365fo_client-0.2.1 → d365fo_client-0.2.2}/src/d365fo_client/metadata_v2/cache_v2.py

@@ -237,7 +237,7 @@ class MetadataCacheV2:
                         entity.public_collection_name,
                         entity.label_id,
                         processed_label_text,  # Use processed label text
-                        entity.entity_category.value if entity.entity_category else None,
+                        entity.entity_category if entity.entity_category else None,
                         entity.data_service_enabled,
                         entity.data_management_enabled,
                         entity.is_read_only,
@@ -481,7 +481,7 @@ class MetadataCacheV2:
                         nav_prop.name,
                         nav_prop.related_entity,
                         nav_prop.related_relation_name,
-                        nav_prop.cardinality.value,  # Convert enum to string value
+                        nav_prop.cardinality,  # StrEnum automatically converts to string
                     ),
                 )
 
@@ -519,7 +519,7 @@ class MetadataCacheV2:
                         entity_id,
                         global_version_id,
                         action.name,
-                        action.binding_kind.value,  # Convert enum to string value
+                        action.binding_kind,  # StrEnum automatically converts to string
                         entity_schema.name,
                         entity_schema.entity_set_name,
                         action.return_type.type_name if action.return_type else None,
@@ -1495,19 +1495,24 @@ class MetadataCacheV2:
         """Get cache statistics
 
         Returns:
-            Dictionary with cache statistics
+            Dictionary with cache statistics scoped to the current environment
         """
+        await self.initialize()
+        
+        if self._environment_id is None:
+            raise ValueError("Environment not initialized")
+            
         stats = {}
 
-        # Database statistics
-        db_stats = await self.database.get_database_statistics()
+        # Environment-scoped database statistics
+        db_stats = await self.database.get_environment_database_statistics(self._environment_id)
         stats.update(db_stats)
 
-        # Version statistics
-        version_stats = await self.version_manager.get_version_statistics()
+        # Environment-scoped version statistics
+        version_stats = await self.version_manager.get_environment_version_statistics(self._environment_id)
         stats["version_manager"] = version_stats
 
-        # Current version info
+        # Current version info (already environment-scoped)
         current_version = await self._get_current_global_version_id()
         if current_version:
             version_info = await self.version_manager.get_global_version_info(
@@ -1521,7 +1526,7 @@ class MetadataCacheV2:
                     "reference_count": version_info.reference_count,
                 }
 
-        # Label cache statistics
+        # Label cache statistics (already environment-scoped via current_version)
         label_stats = await self.get_label_cache_statistics(current_version)
         stats["label_cache"] = label_stats
 

{d365fo_client-0.2.1 → d365fo_client-0.2.2}/src/d365fo_client/metadata_v2/database_v2.py

@@ -542,6 +542,99 @@ class MetadataDatabaseV2:
 
             return stats
 
+    async def get_statistics(self) -> Dict[str, Any]:
+        """Alias for get_database_statistics for backward compatibility
+
+        Returns:
+            Dictionary with database statistics
+        """
+        return await self.get_database_statistics()
+
+    async def get_environment_database_statistics(self, environment_id: int) -> Dict[str, Any]:
+        """Get database statistics scoped to a specific environment
+
+        Args:
+            environment_id: Environment ID to get statistics for
+
+        Returns:
+            Dictionary with environment-scoped database statistics
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            stats = {}
+
+            # Get active global versions for this environment
+            cursor = await db.execute(
+                """SELECT DISTINCT global_version_id 
+                   FROM environment_versions 
+                   WHERE environment_id = ? AND is_active = 1""",
+                (environment_id,)
+            )
+            active_versions = [row[0] for row in await cursor.fetchall()]
+            
+            if not active_versions:
+                # No active versions, return zero counts
+                return {
+                    "data_entities_count": 0,
+                    "public_entities_count": 0,
+                    "entity_properties_count": 0,
+                    "navigation_properties_count": 0,
+                    "entity_actions_count": 0,
+                    "enumerations_count": 0,
+                    "labels_cache_count": 0,
+                    "environment_statistics": {
+                        "total_environments": 1,
+                        "linked_versions": 0,
+                    },
+                    "database_size_bytes": None,
+                    "database_size_mb": None,
+                }
+
+            # Create placeholders for SQL IN clause
+            version_placeholders = ",".join("?" for _ in active_versions)
+
+            # Environment-scoped metadata counts
+            tables = [
+                ("data_entities", "entities"),
+                ("public_entities", "public_entities"),
+                ("entity_properties", "properties"),
+                ("navigation_properties", "navigation_properties"),
+                ("entity_actions", "actions"),
+                ("enumerations", "enumerations"),
+                ("labels_cache", "labels"),
+            ]
+
+            for table, key in tables:
+                cursor = await db.execute(
+                    f"SELECT COUNT(*) FROM {table} WHERE global_version_id IN ({version_placeholders})",
+                    active_versions
+                )
+                stats[f"{table}_count"] = (await cursor.fetchone())[0]
+
+            # Environment-specific statistics
+            cursor = await db.execute(
+                """SELECT 
+                     COUNT(DISTINCT ev.global_version_id) as linked_versions
+                   FROM environment_versions ev
+                   WHERE ev.environment_id = ? AND ev.is_active = 1""",
+                (environment_id,)
+            )
+            env_stats = await cursor.fetchone()
+            stats["environment_statistics"] = {
+                "total_environments": 1,  # Current environment only
+                "linked_versions": env_stats[0] or 0,
+            }
+
+            # Database file size (shared across all environments)
+            try:
+                db_size = self.db_path.stat().st_size
+                stats["database_size_bytes"] = db_size
+                stats["database_size_mb"] = round(db_size / (1024 * 1024), 2)
+            except Exception:
+                stats["database_size_bytes"] = None
+                stats["database_size_mb"] = None
+
+            return stats
+
     async def vacuum_database(self) -> bool:
         """Vacuum database to reclaim space
 

{d365fo_client-0.2.1 → d365fo_client-0.2.2}/src/d365fo_client/metadata_v2/global_version_manager.py

@@ -571,3 +571,63 @@ class GlobalVersionManager:
             }
 
             return stats
+
+    async def get_environment_version_statistics(self, environment_id: int) -> Dict[str, Any]:
+        """Get version statistics scoped to a specific environment
+
+        Args:
+            environment_id: Environment ID to get statistics for
+
+        Returns:
+            Dictionary with environment-scoped version statistics
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            stats = {}
+
+            # Get versions for this specific environment
+            cursor = await db.execute(
+                """SELECT COUNT(DISTINCT global_version_id) 
+                   FROM environment_versions 
+                   WHERE environment_id = ? AND is_active = 1""",
+                (environment_id,)
+            )
+            stats["total_versions"] = (await cursor.fetchone())[0]
+
+            # This environment only
+            stats["total_environments"] = 1
+
+            # Reference statistics for this environment's versions
+            cursor = await db.execute(
+                """SELECT 
+                     SUM(gv.reference_count) as total_references,
+                     AVG(gv.reference_count) as avg_references,
+                     MAX(gv.reference_count) as max_references,
+                     COUNT(*) as versions_with_refs
+                   FROM global_versions gv
+                   INNER JOIN environment_versions ev ON gv.id = ev.global_version_id
+                   WHERE ev.environment_id = ? AND ev.is_active = 1 AND gv.reference_count > 0""",
+                (environment_id,)
+            )
+            ref_stats = await cursor.fetchone()
+            stats["reference_statistics"] = {
+                "total_references": ref_stats[0] or 0,
+                "avg_references": round(ref_stats[1] or 0, 2),
+                "max_references": ref_stats[2] or 0,
+                "versions_with_references": ref_stats[3] or 0,
+            }
+
+            # Version age statistics for this environment
+            cursor = await db.execute(
+                """SELECT 
+                     COUNT(*) as recent_versions
+                   FROM global_versions gv
+                   INNER JOIN environment_versions ev ON gv.id = ev.global_version_id
+                   WHERE ev.environment_id = ? AND ev.is_active = 1
+                   AND gv.last_used_at >= datetime('now', '-7 days')""",
+                (environment_id,)
+            )
+            stats["recent_activity"] = {
+                "versions_used_last_7_days": (await cursor.fetchone())[0]
+            }
+
+            return stats

{d365fo_client-0.2.1 → d365fo_client-0.2.2}/src/d365fo_client/models.py

@@ -4,7 +4,7 @@ import hashlib
 import json
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from enum import Enum
+from enum import Enum, StrEnum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
@@ -14,7 +14,16 @@ if TYPE_CHECKING:
     from typing import ForwardRef
 
 
-class EntityCategory(Enum):
+def _ensure_str_for_json(field):
+    """Ensure field is JSON-serializable as string.
+    
+    StrEnum fields automatically serialize as strings, but this handles
+    the edge case where a field might be None or already a string.
+    """
+    return field  # StrEnum automatically converts to string, None stays None
+
+
+class EntityCategory(StrEnum):
     """D365 F&O Entity Categories"""
 
     MASTER = "Master"
@@ -25,7 +34,7 @@ class EntityCategory(Enum):
     PARAMETERS = "Parameters"
 
 
-class ODataXppType(Enum):
+class ODataXppType(StrEnum):
     """D365 F&O OData XPP Types"""
 
     CONTAINER = "Container"
@@ -42,7 +51,7 @@ class ODataXppType(Enum):
     VOID = "Void"
 
 
-class ODataBindingKind(Enum):
+class ODataBindingKind(StrEnum):
     """D365 F&O Action Binding Types"""
 
     BOUND_TO_ENTITY_INSTANCE = "BoundToEntityInstance"
@@ -50,7 +59,7 @@ class ODataBindingKind(Enum):
     UNBOUND = "Unbound"
 
 
-class SyncStrategy(Enum):
+class SyncStrategy(StrEnum):
     """Metadata synchronization strategies"""
 
     FULL = "full"
@@ -59,7 +68,7 @@ class SyncStrategy(Enum):
     SHARING_MODE = "sharing_mode"
 
 
-class Cardinality(Enum):
+class Cardinality(StrEnum):
     """Navigation Property Cardinality"""
 
     SINGLE = "Single"
@@ -191,7 +200,7 @@ class PublicEntityActionInfo:
     def to_dict(self) -> Dict[str, Any]:
         return {
             "name": self.name,
-            "binding_kind": self.binding_kind.value,  # Convert enum to string value
+            "binding_kind": self.binding_kind,  # StrEnum automatically serializes as string
             "parameters": [param.to_dict() for param in self.parameters],
             "return_type": self.return_type.to_dict() if self.return_type else None,
             "field_lookup": self.field_lookup,
@@ -221,7 +230,7 @@ class DataEntityInfo:
             "label_text": self.label_text,
             "data_service_enabled": self.data_service_enabled,
             "data_management_enabled": self.data_management_enabled,
-            "entity_category": self.entity_category.value if self.entity_category else None,
+            "entity_category": self.entity_category,  # StrEnum automatically serializes as string
             "is_read_only": self.is_read_only,
         }
 
@@ -438,7 +447,7 @@ class NavigationPropertyInfo:
             "name": self.name,
             "related_entity": self.related_entity,
             "related_relation_name": self.related_relation_name,
-            "cardinality": self.cardinality.value,  # Convert enum to string value
+            "cardinality": self.cardinality,  # StrEnum automatically serializes as string
             "constraints": [constraint.to_dict() for constraint in self.constraints],
         }
 
@@ -503,7 +512,7 @@ class ActionInfo:
     def to_dict(self) -> Dict[str, Any]:
         return {
             "name": self.name,
-            "binding_kind": self.binding_kind.value,  # Serialize enum as string value
+            "binding_kind": self.binding_kind,  # StrEnum automatically serializes as string
             "entity_name": self.entity_name,
             "entity_set_name": self.entity_set_name,
             "parameters": [param.to_dict() for param in self.parameters],

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

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