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

d365fo_client/profiles.py

@@ -4,98 +4,91 @@ import logging
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
+from .models import FOClientConfig
+
 if TYPE_CHECKING:
-    from .models import FOClientConfig
     from .credential_sources import CredentialSource
 
 logger = logging.getLogger(__name__)
 
 
 @dataclass
-class Profile:
-    """Unified profile for CLI and MCP operations."""
-
-    # Core identification
-    name: str
+class Profile(FOClientConfig):
+    """Unified profile for CLI and MCP operations.
+    
+    Inherits from FOClientConfig and adds profile-specific functionality
+    like name, description, and CLI output formatting.
+    """
+
+    # Profile-specific identification fields
+    name: str = ""
     description: Optional[str] = None
 
-    # Connection settings
-    base_url: str = ""
-    auth_mode: str = "default"
-    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
-    label_cache_expiry_minutes: int = 60
-    use_cache_first: bool = True
-    cache_dir: Optional[str] = None
-
-    # Localization
-    language: str = "en-US"
-
     # CLI-specific settings (with defaults for MCP)
     output_format: str = "table"
 
-    def to_client_config(self) -> "FOClientConfig":
-        """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=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 __post_init__(self):
+        """Override parent post_init to handle profile-specific validation."""
+        # Call parent validation first
+        super().__post_init__()
+        
+        # Additional profile-specific validation
+        if not self.name:
+            raise ValueError("Profile name is required")
+
+    def to_client_config(self) -> FOClientConfig:
+        """Convert profile to FOClientConfig.
+        
+        Since Profile now inherits from FOClientConfig, we can return a copy
+        of self with only the FOClientConfig fields.
+        """
+        from dataclasses import fields
+        
+        # Get all FOClientConfig field names
+        fo_client_fields = {f.name for f in fields(FOClientConfig)}
+        
+        # Create a dict with only FOClientConfig fields from this instance
+        # Use getattr to preserve object types (especially credential_source)
+        client_data = {}
+        for field_name in fo_client_fields:
+            if hasattr(self, field_name):
+                client_data[field_name] = getattr(self, field_name)
+        
+        return FOClientConfig(**client_data)
 
     def validate(self) -> List[str]:
-        """Validate profile configuration."""
+        """Validate profile configuration.
+        
+        Since Profile inherits from FOClientConfig, we leverage the parent's
+        validation and add profile-specific checks.
+        """
         errors = []
 
-        if not self.base_url:
-            errors.append("Base URL is required")
+        # Profile-specific validation
+        if not self.name:
+            errors.append("Profile name is required")
 
-        if self.auth_mode == "client_credentials":
-            if not self.client_id:
-                errors.append("Client ID is required for client_credentials auth mode")
-            if not self.client_secret:
-                errors.append(
-                    "Client secret is required for client_credentials auth mode"
-                )
-            if not self.tenant_id:
-                errors.append("Tenant ID is required for client_credentials auth mode")
-
-        if self.timeout <= 0:
-            errors.append("Timeout must be greater than 0")
+        # Leverage parent's validation by attempting to create the config
+        try:
+            self._validate_config()
+        except ValueError as e:
+            errors.append(str(e))
 
-        if self.label_cache_expiry_minutes <= 0:
-            errors.append("Label cache expiry must be greater than 0")
+        # Validate credential_source if provided
+        if self.credential_source is not None:
+            # Basic validation - credential source should have a valid source_type
+            if not hasattr(self.credential_source, 'source_type') or not self.credential_source.source_type:
+                errors.append("Credential source must have a valid source_type")
 
         return errors
 
     @classmethod
-    def from_dict(cls, name: str, data: Dict[str, Any]) -> "Profile":
-        """Create Profile from dictionary data with migration support."""
+    def create_from_dict(cls, name: str, data: Dict[str, Any]) -> "Profile":
+        """Create Profile from dictionary data with migration support.
+        
+        This method maintains the same interface as the original from_dict but 
+        works with the inheritance structure.
+        """
 
         # Handle parameter migration from legacy formats
         migrated_data = cls._migrate_legacy_parameters(data.copy())
@@ -103,50 +96,48 @@ class Profile:
         # Ensure name is set
         migrated_data["name"] = name
 
-        # Add defaults for missing parameters
-        defaults = {
+        # Add defaults for missing parameters, focusing on Profile-specific ones
+        profile_defaults = {
+            "name": name,
             "description": None,
-            "base_url": "",
-            "auth_mode": "default",
-            "client_id": None,
-            "client_secret": None,
-            "tenant_id": None,
-            "use_default_credentials": None,
-            "verify_ssl": True,
-            "timeout": 60,
-            "use_label_cache": True,
-            "label_cache_expiry_minutes": 60,
-            "use_cache_first": True,
-            "cache_dir": None,
-            "language": "en-US",
             "output_format": "table",
-            "credential_source": None,
         }
 
-        for key, default_value in defaults.items():
+        for key, default_value in profile_defaults.items():
             if key not in migrated_data:
                 migrated_data[key] = default_value
 
-        # Filter out any unknown parameters
-        valid_params = {
-            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
-
+        # Use parent's from_dict for FOClientConfig fields, then add Profile fields
         try:
+            # Create FOClientConfig from the data first
+            fo_config = super().from_dict(migrated_data)
+            
+            # Convert back to dict and add Profile-specific fields
+            fo_data = fo_config.to_dict()
+            fo_data.update({
+                "name": migrated_data["name"],
+                "description": migrated_data.get("description"),
+                "output_format": migrated_data.get("output_format", "table"),
+            })
+
+            # Filter out any unknown parameters
+            valid_params = {
+                k: v for k, v in fo_data.items() if k in cls.__dataclass_fields__
+            }
+
+            # Handle credential_source deserialization if it's still a dict
+            if "credential_source" in valid_params and isinstance(valid_params["credential_source"], dict):
+                from .credential_sources import CredentialSource
+                try:
+                    valid_params["credential_source"] = CredentialSource.from_dict(valid_params["credential_source"])
+                except Exception as e:
+                    logger.error(f"Error deserializing credential_source: {e}")
+                    valid_params["credential_source"] = None
+
             return cls(**valid_params)
         except Exception as e:
             logger.error(f"Error creating profile {name}: {e}")
-            logger.error(f"Data: {valid_params}")
+            logger.error(f"Data: {migrated_data}")
             raise
 
     @classmethod
@@ -157,6 +148,7 @@ class Profile:
         parameter_migrations = {
             "label_cache": "use_label_cache",
             "label_expiry": "label_cache_expiry_minutes",
+            "cache_dir": "metadata_cache_dir",  # Profile's cache_dir maps to FOClientConfig's metadata_cache_dir
         }
 
         for old_name, new_name in parameter_migrations.items():
@@ -164,20 +156,31 @@ class Profile:
                 data[new_name] = data.pop(old_name)
                 logger.debug(f"Migrated parameter {old_name} -> {new_name}")
 
+        # Special handling for Profile's legacy credential migration
+        # If auth_mode is "client_credentials", treat it as explicit credentials
+        if data.get("auth_mode") == "client_credentials":
+            data["use_default_credentials"] = False
+            logger.debug("Setting use_default_credentials=False for client_credentials auth_mode")
+
+        # Migrate legacy credential fields to credential_source (use parent method)
+        data = FOClientConfig._migrate_legacy_credentials(data)
+
         return data
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert profile to dictionary for storage."""
-        from dataclasses import asdict
-
-        # Convert to dict and remove name (stored as key)
-        data = asdict(self)
+        # Use parent's to_dict method and remove profile-specific fields that shouldn't be in storage
+        data = super().to_dict()
+        
+        # Add profile-specific fields
+        data.update({
+            "description": self.description,
+            "output_format": self.output_format,
+        })
+        
+        # Remove name from storage (it's stored as the key)
         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":
@@ -195,11 +198,13 @@ class Profile:
 
     def __str__(self) -> str:
         """String representation of the profile."""
-        return f"Profile(name='{self.name}', base_url='{self.base_url}', auth_mode='{self.auth_mode}')"
+        cred_info = "default_credentials" if self.credential_source is None else f"credential_source={self.credential_source.source_type}"
+        return f"Profile(name='{self.name}', base_url='{self.base_url}', auth={cred_info})"
 
     def __repr__(self) -> str:
         """Detailed string representation of the profile."""
+        cred_info = "default_credentials" if self.credential_source is None else f"credential_source={self.credential_source.source_type}"
         return (
             f"Profile(name='{self.name}', base_url='{self.base_url}', "
-            f"auth_mode='{self.auth_mode}', description='{self.description}')"
+            f"auth={cred_info}, description='{self.description}')"
         )

d365fo_client/settings.py

@@ -0,0 +1,355 @@
+"""Pydantic settings model for environment variable management."""
+
+import os
+from enum import Enum
+from pathlib import Path
+from typing import Literal, Optional
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from .utils import get_default_cache_directory
+
+
+class LogLevel(str, Enum):
+    """Valid logging levels."""
+    
+    DEBUG = "DEBUG"
+    INFO = "INFO" 
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class TransportProtocol(str, Enum):
+    """Valid MCP transport protocols."""
+    
+    STDIO = "stdio"
+    SSE = "sse"
+    HTTP = "http"
+    STREAMABLE_HTTP = "streamable-http"
+
+
+class D365FOSettings(BaseSettings):
+    """Pydantic settings model for D365FO environment variables.
+    
+    This model provides type-safe access to all D365FO environment variables
+    with proper validation, defaults, and documentation.
+    """
+    
+    model_config = SettingsConfigDict(
+        env_prefix="D365FO_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=True,
+        extra="ignore",
+    )
+    
+    # === Core D365FO Connection Settings ===
+    
+    base_url: Optional[str] = Field(
+        default="https://usnconeboxax1aos.cloud.onebox.dynamics.com",
+        description="D365FO environment URL",
+        alias="D365FO_BASE_URL"
+    )
+    
+    # === Azure AD Authentication Settings ===
+    
+    client_id: Optional[str] = Field(
+        default=None,
+        description="Azure AD client ID (optional, used with client credentials flow)",
+        alias="D365FO_CLIENT_ID"
+    )
+    
+    client_secret: Optional[str] = Field(
+        default=None,
+        description="Azure AD client secret (optional, used with client credentials flow)",
+        alias="D365FO_CLIENT_SECRET"
+    )
+    
+    tenant_id: Optional[str] = Field(
+        default=None,
+        description="Azure AD tenant ID (optional, used with client credentials flow)",
+        alias="D365FO_TENANT_ID"
+    )
+    
+    # === MCP Authentication Settings ===
+    
+    mcp_auth_client_id: Optional[str] = Field(
+        default=None,
+        description="MCP authentication client ID",
+        alias="D365FO_MCP_AUTH_CLIENT_ID"
+    )
+    
+    mcp_auth_client_secret: Optional[str] = Field(
+        default=None,
+        description="MCP authentication client secret",
+        alias="D365FO_MCP_AUTH_CLIENT_SECRET"
+    )
+    
+    mcp_auth_tenant_id: Optional[str] = Field(
+        default=None,
+        description="MCP authentication tenant ID",
+        alias="D365FO_MCP_AUTH_TENANT_ID"
+    )
+    
+    mcp_auth_base_url: str = Field(
+        default="http://localhost:8000",
+        description="MCP authentication base URL",
+        alias="D365FO_MCP_AUTH_BASE_URL"
+    )
+    
+    mcp_auth_required_scopes: str = Field(
+        default="User.Read,email,openid,profile",
+        description="MCP authentication required scopes (comma-separated)",
+        alias="D365FO_MCP_AUTH_REQUIRED_SCOPES"
+    )
+    
+    # === MCP Server Transport Settings ===
+    
+    mcp_transport: TransportProtocol = Field(
+        default=TransportProtocol.STDIO,
+        description="Default transport protocol (stdio, sse, http, streamable-http)",
+        alias="D365FO_MCP_TRANSPORT"
+    )
+    
+    http_host: str = Field(
+        default="127.0.0.1",
+        description="Default HTTP host",
+        alias="D365FO_MCP_HTTP_HOST"
+    )
+    
+    http_port: int = Field(
+        default=8000,
+        gt=0,
+        le=65535,
+        description="Default HTTP port",
+        alias="D365FO_MCP_HTTP_PORT"
+    )
+    
+    http_stateless: bool = Field(
+        default=False,
+        description="Enable stateless mode (true/false)",
+        alias="D365FO_MCP_HTTP_STATELESS"
+    )
+    
+    http_json: bool = Field(
+        default=False,
+        description="Enable JSON response mode (true/false)",
+        alias="D365FO_MCP_HTTP_JSON"
+    )
+    
+    # === Connection and Performance Settings ===
+    
+    max_concurrent_requests: int = Field(
+        default=10,
+        gt=0,
+        description="Max concurrent requests",
+        alias="D365FO_MCP_MAX_CONCURRENT_REQUESTS"
+    )
+    
+    request_timeout: int = Field(
+        default=30,
+        gt=0,
+        description="Request timeout in seconds",
+        alias="D365FO_MCP_REQUEST_TIMEOUT"
+    )
+    
+    timeout: int = Field(
+        default=60,
+        gt=0,
+        description="General timeout in seconds",
+        alias="D365FO_TIMEOUT"
+    )
+    
+    verify_ssl: bool = Field(
+        default=True,
+        description="Verify SSL certificates",
+        alias="D365FO_VERIFY_SSL"
+    )
+    
+    # === Logging Settings ===
+    
+    log_level: LogLevel = Field(
+        default=LogLevel.INFO,
+        description="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+        alias="D365FO_LOG_LEVEL"
+    )
+    
+    log_file: Optional[str] = Field(
+        default=None,
+        description="Custom log file path (default: ~/.d365fo-mcp/logs/fastmcp-server.log)",
+        alias="D365FO_LOG_FILE"
+    )
+    
+    # === Cache and Metadata Settings ===
+    
+    cache_dir: Optional[str] = Field(
+        default=None,
+        description="General cache directory",
+        alias="D365FO_CACHE_DIR"
+    )
+    
+    meta_cache_dir: Optional[str] = Field(
+        default=None,
+        description="Metadata cache directory (default: ~/.d365fo-mcp/cache)",
+        alias="D365FO_META_CACHE_DIR"
+    )
+    
+    use_label_cache: bool = Field(
+        default=True,
+        description="Enable label caching",
+        alias="D365FO_LABEL_CACHE"
+    )
+    
+    label_cache_expiry_minutes: int = Field(
+        default=1440,  # 24 hours
+        gt=0,
+        description="Label cache expiry in minutes",
+        alias="D365FO_LABEL_EXPIRY"
+    )
+    
+    use_cache_first: bool = Field(
+        default=True,
+        description="Use cache first before making API calls",
+        alias="D365FO_USE_CACHE_FIRST"
+    )
+    
+    # === Debug and Development Settings ===
+    
+    debug: bool = Field(
+        default=False,
+        description="Enable debug mode",
+        alias="DEBUG"
+    )
+    
+    @field_validator("log_file", mode="before")
+    @classmethod
+    def validate_log_file(cls, v):
+        """Validate and set default log file path."""
+        if v is None:
+            # Return default log file path
+            log_dir = Path.home() / ".d365fo-mcp" / "logs"
+            return str(log_dir / "fastmcp-server.log")
+        return v
+    
+    @field_validator("cache_dir", mode="before")
+    @classmethod
+    def validate_cache_dir(cls, v):
+        """Validate and set default cache directory."""
+        if v is None:
+            return get_default_cache_directory()
+        return v
+    
+    @field_validator("meta_cache_dir", mode="before")
+    @classmethod
+    def validate_meta_cache_dir(cls, v):
+        """Validate and set default metadata cache directory."""
+        if v is None:
+            cache_dir = Path.home() / ".d365fo-mcp" / "cache"
+            return str(cache_dir)
+        return v
+    
+    @field_validator("http_stateless", "http_json", "use_label_cache", "use_cache_first", "verify_ssl", "debug", mode="before")
+    @classmethod
+    def validate_boolean_env_vars(cls, v):
+        """Convert string environment variables to booleans."""
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes", "on")
+        return v
+    
+    def get_default_log_file(self) -> str:
+        """Get the default log file path."""
+        log_dir = Path.home() / ".d365fo-mcp" / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        return str(log_dir / "fastmcp-server.log")
+    
+    def ensure_directories(self) -> None:
+        """Ensure all required directories exist."""
+        # Ensure log file directory exists
+        if self.log_file:
+            log_dir = Path(self.log_file).parent
+            log_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Ensure cache directories exist
+        if self.cache_dir:
+            Path(self.cache_dir).mkdir(parents=True, exist_ok=True)
+            
+        if self.meta_cache_dir:
+            Path(self.meta_cache_dir).mkdir(parents=True, exist_ok=True)
+    
+    def has_client_credentials(self) -> bool:
+        """Check if client credentials are configured."""
+        return all([self.client_id, self.client_secret, self.tenant_id])
+    
+    def has_mcp_auth_credentials(self) -> bool:
+        """Check if MCP authentication credentials are configured."""
+        return all([self.mcp_auth_client_id, self.mcp_auth_client_secret, self.mcp_auth_tenant_id])
+    
+    def get_startup_mode(self) -> Literal["profile_only", "default_auth", "client_credentials"]:
+        """Determine startup mode based on configuration."""
+        if self.base_url and self.base_url != "https://usnconeboxax1aos.cloud.onebox.dynamics.com":
+            if self.has_client_credentials():
+                return "client_credentials"
+            else:
+                return "default_auth"
+        return "profile_only"
+    
+    def mcp_auth_required_scopes_list(self) -> list[str]:
+        """Get MCP authentication required scopes as a list."""
+        return [scope.strip() for scope in self.mcp_auth_required_scopes.split(",") if scope.strip()]
+    
+    def to_dict(self) -> dict:
+        """Convert settings to dictionary."""
+        return self.dict()
+    
+    def to_env_dict(self) -> dict:
+        """Convert settings to environment variable dictionary."""
+        env_dict = {}
+        for field_name, field_info in self.model_fields.items():
+            value = getattr(self, field_name)
+            if value is not None:
+                # Use the alias if available, otherwise construct the env var name
+                if field_info.alias:
+                    env_var_name = field_info.alias
+                else:
+                    env_var_name = f"D365FO_{field_name.upper()}"
+                
+                # Convert boolean values to string
+                if isinstance(value, bool):
+                    env_dict[env_var_name] = "true" if value else "false"
+                else:
+                    env_dict[env_var_name] = str(value)
+        
+        return env_dict
+
+
+# Global settings instance
+_settings: Optional[D365FOSettings] = None
+
+
+def get_settings(reload: bool = False) -> D365FOSettings:
+    """Get the global settings instance.
+    
+    Args:
+        reload: If True, force reload settings from environment
+        
+    Returns:
+        D365FOSettings instance
+    """
+    global _settings
+    
+    if _settings is None or reload:
+        _settings = D365FOSettings()
+        _settings.ensure_directories()
+    
+    return _settings
+
+
+def reset_settings() -> None:
+    """Reset the global settings instance.
+    
+    Useful for testing when you want to reload settings.
+    """
+    global _settings
+    _settings = None