d365fo-client 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

d365fo_client/models.py

@@ -12,6 +12,7 @@ from .utils import get_environment_cache_directory
 
 if TYPE_CHECKING:
     from typing import ForwardRef
+    from .credential_sources import CredentialSource
 
 
 def _ensure_str_for_json(field):
@@ -65,7 +66,10 @@ class SyncStrategy(StrEnum):
     FULL = "full"
     INCREMENTAL = "incremental"
     ENTITIES_ONLY = "entities_only"
+    LABELS_ONLY = "labels_only"
     SHARING_MODE = "sharing_mode"
+    FULL_WITHOUT_LABELS = "full_without_labels"
+
 
 
 class Cardinality(StrEnum):
@@ -80,6 +84,7 @@ class FOClientConfig:
     """Configuration for F&O Client"""
 
     base_url: str
+    auth_mode: Optional[str] = "defaut" # default | client_credentials
     client_id: Optional[str] = None
     client_secret: Optional[str] = None
     tenant_id: Optional[str] = None
@@ -98,6 +103,8 @@ class FOClientConfig:
     max_memory_cache_size: int = 1000
     # Cache-first behavior configuration
     use_cache_first: bool = True
+    # Credential source configuration
+    credential_source: Optional["CredentialSource"] = None
 
     def __post_init__(self):
         """Post-initialization to set default cache directory if not provided."""
@@ -738,9 +745,9 @@ class GlobalVersionInfo:
     first_seen_at: datetime
     last_used_at: datetime
     reference_count: int
-    sample_modules: List[ModuleVersionInfo] = field(
+    modules: List[ModuleVersionInfo] = field(
         default_factory=list
-    )  # Sample for debugging
+    )  # Modules for debugging
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for JSON serialization"""
@@ -751,7 +758,7 @@ class GlobalVersionInfo:
             "first_seen_at": self.first_seen_at.isoformat(),
             "last_used_at": self.last_used_at.isoformat(),
             "reference_count": self.reference_count,
-            "sample_modules": [module.to_dict() for module in self.sample_modules],
+            "modules": [module.to_dict() for module in self.modules],
         }
 
 
@@ -869,3 +876,15 @@ class SyncResult:
     action_count: int
     enumeration_count: int
     label_count: int
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "success": self.success,
+            "error": self.error,
+            "duration_ms": self.duration_ms,
+            "entity_count": self.entity_count,
+            "action_count": self.action_count,
+            "enumeration_count": self.enumeration_count,
+            "label_count": self.label_count
+        }

d365fo_client/profile_manager.py

@@ -7,13 +7,15 @@ import logging
 import os
 from dataclasses import asdict
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 import yaml
 
 from .config import ConfigManager
 from .models import FOClientConfig
 from .profiles import Profile
+if TYPE_CHECKING:
+    from .credential_sources import CredentialSource
 
 logger = logging.getLogger(__name__)
 
@@ -76,6 +78,8 @@ class ProfileManager:
         language: str = "en-US",
         cache_dir: Optional[str] = None,
         description: Optional[str] = None,
+        credential_source: Optional["CredentialSource"] = None
+
     ) -> bool:
         """Create a new profile.
 
@@ -93,6 +97,7 @@ class ProfileManager:
             language: Default language code
             cache_dir: Cache directory path
             description: Profile description (stored separately from CLI profile)
+            credential_source: Credential source configuration
 
         Returns:
             True if created successfully
@@ -120,6 +125,7 @@ class ProfileManager:
                 cache_dir=cache_dir,
                 description=description,
                 output_format="table",  # Default for CLI compatibility
+                credential_source=credential_source
             )
 
             self.config_manager.save_profile(profile)

d365fo_client/profiles.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 if TYPE_CHECKING:
     from .models import FOClientConfig
+    from .credential_sources import CredentialSource
 
 logger = logging.getLogger(__name__)
 
@@ -24,8 +25,10 @@ class Profile:
     client_id: Optional[str] = None
     client_secret: Optional[str] = None
     tenant_id: Optional[str] = None
+    use_default_credentials: Optional[bool] = None  # None means derive from auth_mode
     verify_ssl: bool = True
     timeout: int = 60
+    credential_source: Optional["CredentialSource"] = None
 
     # Cache settings
     use_label_cache: bool = True
@@ -43,18 +46,26 @@ class Profile:
         """Convert profile to FOClientConfig."""
         from .models import FOClientConfig
 
+        # Determine use_default_credentials: explicit setting takes precedence over auth_mode
+        if self.use_default_credentials is not None:
+            use_default_creds = self.use_default_credentials
+        else:
+            use_default_creds = self.auth_mode == "default"
+
         return FOClientConfig(
             base_url=self.base_url,
+            auth_mode=self.auth_mode,
             client_id=self.client_id,
             client_secret=self.client_secret,
             tenant_id=self.tenant_id,
-            use_default_credentials=self.auth_mode == "default",
+            use_default_credentials=use_default_creds,
             timeout=self.timeout,
             verify_ssl=self.verify_ssl,
             use_label_cache=self.use_label_cache,
             label_cache_expiry_minutes=self.label_cache_expiry_minutes,
             use_cache_first=self.use_cache_first,
             metadata_cache_dir=self.cache_dir,
+            credential_source=self.credential_source,
         )
 
     def validate(self) -> List[str]:
@@ -100,6 +111,7 @@ class Profile:
             "client_id": None,
             "client_secret": None,
             "tenant_id": None,
+            "use_default_credentials": None,
             "verify_ssl": True,
             "timeout": 60,
             "use_label_cache": True,
@@ -108,6 +120,7 @@ class Profile:
             "cache_dir": None,
             "language": "en-US",
             "output_format": "table",
+            "credential_source": None,
         }
 
         for key, default_value in defaults.items():
@@ -119,6 +132,16 @@ class Profile:
             k: v for k, v in migrated_data.items() if k in cls.__dataclass_fields__
         }
 
+        # Handle credential_source deserialization
+        if "credential_source" in valid_params and valid_params["credential_source"] is not None:
+            from .credential_sources import CredentialSource
+            credential_source_data = valid_params["credential_source"]
+            try:
+                valid_params["credential_source"] = CredentialSource.from_dict(credential_source_data)
+            except Exception as e:
+                logger.error(f"Error deserializing credential_source: {e}")
+                valid_params["credential_source"] = None
+
         try:
             return cls(**valid_params)
         except Exception as e:
@@ -151,6 +174,10 @@ class Profile:
         data = asdict(self)
         data.pop("name", None)
 
+        # Handle credential_source serialization
+        if self.credential_source is not None:
+            data["credential_source"] = self.credential_source.to_dict()
+
         return data
 
     def clone(self, name: str, **overrides) -> "Profile":

d365fo_client/sync_models.py

@@ -0,0 +1,181 @@
+"""Enhanced sync models for progress reporting and session management."""
+
+import uuid
+from datetime import datetime, timezone
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Dict, List, Optional, Callable, Set
+
+from .models import SyncStrategy, SyncResult
+
+
+class SyncStatus(StrEnum):
+    """Sync operation status"""
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+    PAUSED = "paused"
+
+
+class SyncPhase(StrEnum):
+    """Detailed sync phases"""
+    INITIALIZING = "initializing"
+    VERSION_CHECK = "version_check"
+    ENTITIES = "entities"
+    SCHEMAS = "schemas"
+    ENUMERATIONS = "enumerations"
+    LABELS = "labels"
+    INDEXING = "indexing"
+    FINALIZING = "finalizing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+@dataclass
+class SyncActivity:
+    """Individual sync activity within a phase"""
+    name: str
+    status: SyncStatus
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None
+    progress_percent: float = 0.0
+    items_processed: int = 0
+    items_total: Optional[int] = None
+    current_item: Optional[str] = None
+    error: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "name": self.name,
+            "status": self.status,
+            "start_time": self.start_time.isoformat() if self.start_time else None,
+            "end_time": self.end_time.isoformat() if self.end_time else None,
+            "progress_percent": self.progress_percent,
+            "items_processed": self.items_processed,
+            "items_total": self.items_total,
+            "current_item": self.current_item,
+            "error": self.error
+        }
+
+
+@dataclass
+class SyncSession:
+    """Complete sync session with detailed tracking"""
+    session_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    global_version_id: int = 0
+    strategy: SyncStrategy = SyncStrategy.FULL
+    status: SyncStatus = SyncStatus.PENDING
+    
+    # Overall progress
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None
+    estimated_completion: Optional[datetime] = None
+    progress_percent: float = 0.0
+    
+    # Current state
+    current_phase: SyncPhase = SyncPhase.INITIALIZING
+    current_activity: Optional[str] = None
+    
+    # Phase tracking
+    phases: Dict[SyncPhase, SyncActivity] = field(default_factory=dict)
+    
+    # Results
+    result: Optional[SyncResult] = None
+    error: Optional[str] = None
+    
+    # Metadata
+    initiated_by: str = "system"  # user, system, scheduled, mcp
+    can_cancel: bool = True
+    
+    # Collected label IDs during sync for efficient label processing
+    collected_label_ids: Set[str] = field(default_factory=set)
+    
+    def get_overall_progress(self) -> float:
+        """Calculate overall progress across all phases"""
+        if not self.phases:
+            return 0.0
+            
+        total_weight = len(self.phases)
+        completed_weight = sum(
+            1.0 if activity.status == SyncStatus.COMPLETED 
+            else activity.progress_percent / 100.0
+            for activity in self.phases.values()
+        )
+        return min(100.0, (completed_weight / total_weight) * 100.0)
+    
+    def get_current_activity_detail(self) -> Optional[SyncActivity]:
+        """Get current running activity details"""
+        if self.current_phase in self.phases:
+            return self.phases[self.current_phase]
+        return None
+    
+    def estimate_remaining_time(self) -> Optional[int]:
+        """Estimate remaining time in seconds"""
+        if not self.start_time or self.progress_percent <= 0:
+            return None
+            
+        elapsed = (datetime.now(timezone.utc) - self.start_time).total_seconds()
+        if self.progress_percent >= 100:
+            return 0
+            
+        estimated_total = elapsed / (self.progress_percent / 100.0)
+        return max(0, int(estimated_total - elapsed))
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "session_id": self.session_id,
+            "global_version_id": self.global_version_id,
+            "strategy": self.strategy,
+            "status": self.status,
+            "start_time": self.start_time.isoformat() if self.start_time else None,
+            "end_time": self.end_time.isoformat() if self.end_time else None,
+            "estimated_completion": self.estimated_completion.isoformat() if self.estimated_completion else None,
+            "progress_percent": self.progress_percent,
+            "current_phase": self.current_phase,
+            "current_activity": self.current_activity,
+            "phases": {
+                phase.value: activity.to_dict()
+                for phase, activity in self.phases.items()
+            },
+            "result": self.result.to_dict() if self.result and hasattr(self.result, 'to_dict') else None,
+            "error": self.error,
+            "initiated_by": self.initiated_by,
+            "can_cancel": self.can_cancel,
+            "estimated_remaining_seconds": self.estimate_remaining_time()
+        }
+
+
+@dataclass
+class SyncSessionSummary:
+    """Lightweight sync session summary for listing"""
+    session_id: str
+    global_version_id: int
+    strategy: SyncStrategy
+    status: SyncStatus
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None
+    progress_percent: float = 0.0
+    current_phase: SyncPhase = SyncPhase.INITIALIZING
+    current_activity: Optional[str] = None
+    initiated_by: str = "system"
+    duration_seconds: Optional[int] = None
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "session_id": self.session_id,
+            "global_version_id": self.global_version_id,
+            "strategy": self.strategy,
+            "status": self.status,
+            "start_time": self.start_time.isoformat() if self.start_time else None,
+            "end_time": self.end_time.isoformat() if self.end_time else None,
+            "progress_percent": self.progress_percent,
+            "current_phase": self.current_phase,
+            "current_activity": self.current_activity,
+            "initiated_by": self.initiated_by,
+            "duration_seconds": self.duration_seconds
+        }