duckrun 0.2.7__tar.gz → 0.2.9__tar.gz

{duckrun-0.2.7 → duckrun-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckrun
-Version: 0.2.7
+Version: 0.2.9
 Summary: Lakehouse task runner powered by DuckDB for Microsoft Fabric
 Author: mim
 License: MIT
@@ -420,6 +420,37 @@ success = con.run(pipeline)  # Returns True only if ALL tasks succeed
 
 This prevents downstream tasks from processing incomplete or corrupted data.
 
+### Semantic Model Deployment
+
+Deploy Power BI semantic models directly from BIM files using DirectLake mode:
+
+```python
+# Connect to lakehouse
+con = duckrun.connect("Analytics/Sales.lakehouse/dbo")
+
+# Deploy with auto-generated name (lakehouse_schema)
+con.deploy("https://raw.githubusercontent.com/user/repo/main/model.bim")
+
+# Deploy with custom name
+con.deploy(
+    "https://raw.githubusercontent.com/user/repo/main/sales_model.bim",
+    dataset_name="Sales Analytics Model",
+    wait_seconds=10  # Wait for permission propagation
+)
+```
+
+**Features:**
+- 🚀 **DirectLake Mode**: Deploys semantic models with DirectLake connection
+- 🔄 **Automatic Configuration**: Auto-configures workspace, lakehouse, and schema connections
+- 📦 **BIM from URL**: Load model definitions from GitHub or any accessible URL
+- ⏱️ **Permission Handling**: Configurable wait time for permission propagation
+
+**Use Cases:**
+- Deploy semantic models as part of CI/CD pipelines
+- Version control your semantic models in Git
+- Automated model deployment across environments
+- Streamline DirectLake model creation
+
 ### Delta Lake Optimization
 
 Duckrun automatically:
@@ -534,6 +565,12 @@ con.sql("""
 
 # 5. Download processed files for external systems
 con.download("processed_reports", "./exports", ['.csv'])
+
+# 6. Deploy semantic model for Power BI
+con.deploy(
+    "https://raw.githubusercontent.com/user/repo/main/sales_model.bim",
+    dataset_name="Sales Analytics"
+)
 ```
 
 **This example demonstrates:**
@@ -541,8 +578,9 @@ con.download("processed_reports", "./exports", ['.csv'])
 - 🔄 **Pipeline orchestration** with SQL and Python tasks  
 - ⚡ **Fast data exploration** with DuckDB
 - 💾 **Delta table creation** with Spark-style API
-- � **Schema evolution** and partitioning
-- �📤 **File downloads** from OneLake Files
+- 🔀 **Schema evolution** and partitioning
+- 📤 **File downloads** from OneLake Files
+- 📊 **Semantic model deployment** with DirectLake
 
 ## Schema Evolution & Partitioning Guide
 

{duckrun-0.2.7 → duckrun-0.2.9}/README.md

@@ -400,6 +400,37 @@ success = con.run(pipeline)  # Returns True only if ALL tasks succeed
 
 This prevents downstream tasks from processing incomplete or corrupted data.
 
+### Semantic Model Deployment
+
+Deploy Power BI semantic models directly from BIM files using DirectLake mode:
+
+```python
+# Connect to lakehouse
+con = duckrun.connect("Analytics/Sales.lakehouse/dbo")
+
+# Deploy with auto-generated name (lakehouse_schema)
+con.deploy("https://raw.githubusercontent.com/user/repo/main/model.bim")
+
+# Deploy with custom name
+con.deploy(
+    "https://raw.githubusercontent.com/user/repo/main/sales_model.bim",
+    dataset_name="Sales Analytics Model",
+    wait_seconds=10  # Wait for permission propagation
+)
+```
+
+**Features:**
+- 🚀 **DirectLake Mode**: Deploys semantic models with DirectLake connection
+- 🔄 **Automatic Configuration**: Auto-configures workspace, lakehouse, and schema connections
+- 📦 **BIM from URL**: Load model definitions from GitHub or any accessible URL
+- ⏱️ **Permission Handling**: Configurable wait time for permission propagation
+
+**Use Cases:**
+- Deploy semantic models as part of CI/CD pipelines
+- Version control your semantic models in Git
+- Automated model deployment across environments
+- Streamline DirectLake model creation
+
 ### Delta Lake Optimization
 
 Duckrun automatically:
@@ -514,6 +545,12 @@ con.sql("""
 
 # 5. Download processed files for external systems
 con.download("processed_reports", "./exports", ['.csv'])
+
+# 6. Deploy semantic model for Power BI
+con.deploy(
+    "https://raw.githubusercontent.com/user/repo/main/sales_model.bim",
+    dataset_name="Sales Analytics"
+)
 ```
 
 **This example demonstrates:**
@@ -521,8 +558,9 @@ con.download("processed_reports", "./exports", ['.csv'])
 - 🔄 **Pipeline orchestration** with SQL and Python tasks  
 - ⚡ **Fast data exploration** with DuckDB
 - 💾 **Delta table creation** with Spark-style API
-- � **Schema evolution** and partitioning
-- �📤 **File downloads** from OneLake Files
+- 🔀 **Schema evolution** and partitioning
+- 📤 **File downloads** from OneLake Files
+- 📊 **Semantic model deployment** with DirectLake
 
 ## Schema Evolution & Partitioning Guide
 

{duckrun-0.2.7 → duckrun-0.2.9}/duckrun/__init__.py

@@ -2,7 +2,7 @@
 
 from duckrun.core import Duckrun
 
-__version__ = "0.1.0"
+__version__ = "0.2.9.dev5"
 
 # Expose unified connect method at module level
 connect = Duckrun.connect

duckrun-0.2.9/duckrun/auth.py

@@ -0,0 +1,249 @@
+"""
+Enhanced authentication module for duckrun - supports multiple notebook environments
+"""
+import os
+from typing import Optional, Tuple
+
+
+def get_token() -> Optional[str]:
+    """
+    Smart authentication that works across multiple environments:
+    - Microsoft Fabric notebooks (uses notebookutils)
+    - Local environments with Azure CLI (uses CLI + browser fallback)
+    - Google Colab (uses device code flow) 
+    - Other headless environments (uses device code flow)
+    - Existing token from environment (uses cached token)
+    
+    Returns:
+        Azure Storage token string or None if authentication fails
+    """
+    # Check if we already have a cached token
+    token_env = os.environ.get("AZURE_STORAGE_TOKEN")
+    if token_env and token_env != "PLACEHOLDER_TOKEN_TOKEN_NOT_AVAILABLE":
+        print("✅ Using existing Azure Storage token")
+        return token_env
+
+    print("🔐 Starting Azure authentication...")
+    
+    # Try Fabric notebook environment first
+    try:
+        import notebookutils  # type: ignore
+        print("📓 Microsoft Fabric notebook detected - using notebookutils")
+        token = notebookutils.credentials.getToken("pbi")
+        os.environ["AZURE_STORAGE_TOKEN"] = token
+        print("✅ Fabric notebook authentication successful!")
+        return token
+    except ImportError:
+        pass  # Not in Fabric notebook
+    except Exception as e:
+        print(f"⚠️ Fabric notebook authentication failed: {e}")
+
+    # Detect environment type for fallback authentication
+    try:
+        # Check if we're in Google Colab first
+        try:
+            import google.colab
+            print("🚀 Google Colab detected - using device code flow")
+            return _get_device_code_token()
+        except ImportError:
+            pass
+
+        # For all other environments (including VS Code), try Azure CLI first
+        # This includes local development, VS Code notebooks, etc.
+        print("🖥️ Local/VS Code environment detected - trying Azure CLI first, then browser fallback")
+        return _get_local_token()
+
+    except Exception as e:
+        print(f"❌ Authentication failed: {e}")
+        print("💡 Try refreshing and running again, or check your Azure permissions")
+        return None
+
+
+def _get_device_code_token() -> Optional[str]:
+    """Get token using device code flow for headless environments"""
+    try:
+        from azure.identity import DeviceCodeCredential
+        
+        # Use Azure CLI client ID for device code flow
+        credential = DeviceCodeCredential(
+            client_id="04b07795-8ddb-461a-bbee-02f9e1bf7b46",  # Azure CLI client ID
+            tenant_id="common"
+        )
+        
+        print("🔐 Follow the authentication prompts in your browser...")
+        token_obj = credential.get_token("https://storage.azure.com/.default")
+        
+        os.environ["AZURE_STORAGE_TOKEN"] = token_obj.token
+        print("✅ Device code authentication successful!")
+        return token_obj.token
+        
+    except Exception as e:
+        print(f"❌ Device code authentication failed: {e}")
+        return None
+
+
+def _get_local_token() -> Optional[str]:
+    """Get token using CLI first, then browser fallback for local environments"""
+    # First try Azure CLI directly
+    try:
+        from azure.identity import AzureCliCredential
+        print("🔐 Trying Azure CLI authentication...")
+        
+        cli_credential = AzureCliCredential()
+        token_obj = cli_credential.get_token("https://storage.azure.com/.default")
+        
+        os.environ["AZURE_STORAGE_TOKEN"] = token_obj.token
+        print("✅ Azure CLI authentication successful!")
+        return token_obj.token
+        
+    except Exception as cli_error:
+        print(f"⚠️ Azure CLI authentication failed: {cli_error}")
+        print("🔐 Falling back to interactive browser authentication...")
+        
+        # Fallback to interactive browser
+        try:
+            from azure.identity import InteractiveBrowserCredential
+            
+            browser_credential = InteractiveBrowserCredential()
+            token_obj = browser_credential.get_token("https://storage.azure.com/.default")
+            
+            os.environ["AZURE_STORAGE_TOKEN"] = token_obj.token
+            print("✅ Interactive browser authentication successful!")
+            return token_obj.token
+            
+        except Exception as browser_error:
+            print(f"❌ Interactive browser authentication failed: {browser_error}")
+            return None
+
+
+def get_fabric_api_token() -> Optional[str]:
+    """
+    Get token for Fabric API operations (different scope than storage)
+    
+    Returns:
+        Fabric API token string or None if authentication fails
+    """
+    # Check if we already have a cached Fabric API token
+    fabric_token_env = os.environ.get("FABRIC_API_TOKEN")
+    if fabric_token_env:
+        print("✅ Using cached Fabric API token")
+        return fabric_token_env
+    
+    print("🔐 Getting Fabric API token...")
+    
+    # Try Fabric notebook environment first
+    try:
+        import notebookutils  # type: ignore
+        print("📓 Microsoft Fabric notebook detected - using notebookutils")
+        token = notebookutils.credentials.getToken("pbi")
+        os.environ["FABRIC_API_TOKEN"] = token
+        print("✅ Fabric API token obtained!")
+        return token
+    except ImportError:
+        pass  # Not in Fabric notebook
+    except Exception as e:
+        print(f"⚠️ Fabric notebook token failed: {e}")
+
+    # Fallback to azure-identity for external environments
+    try:
+        # Check if we're in Google Colab
+        try:
+            import google.colab
+            print("💻 Using device code flow for Fabric API (Colab)")
+            from azure.identity import DeviceCodeCredential
+            credential = DeviceCodeCredential(
+                client_id="04b07795-8ddb-461a-bbee-02f9e1bf7b46",
+                tenant_id="common"
+            )
+        except ImportError:
+            # For all other environments, try CLI first then browser
+            print("🖥️ Using CLI + browser fallback for Fabric API")
+            
+            # Try CLI first
+            try:
+                from azure.identity import AzureCliCredential
+                print("🔐 Trying Azure CLI for Fabric API...")
+                credential = AzureCliCredential()
+                token_obj = credential.get_token("https://api.fabric.microsoft.com/.default")
+                os.environ["FABRIC_API_TOKEN"] = token_obj.token
+                print("✅ Fabric API token obtained via Azure CLI!")
+                return token_obj.token
+            except Exception as cli_error:
+                print(f"⚠️ Azure CLI failed for Fabric API: {cli_error}")
+                print("🔐 Falling back to interactive browser for Fabric API...")
+                from azure.identity import InteractiveBrowserCredential
+                credential = InteractiveBrowserCredential()
+        
+        token_obj = credential.get_token("https://api.fabric.microsoft.com/.default")
+        os.environ["FABRIC_API_TOKEN"] = token_obj.token
+        print("✅ Fabric API token obtained!")
+        return token_obj.token
+        
+    except Exception as e:
+        print(f"❌ Fabric API authentication failed: {e}")
+        return None
+
+
+def authenticate_for_environment() -> Tuple[bool, Optional[str]]:
+    """
+    Main authentication entry point - detects environment and authenticates appropriately
+    
+    Returns:
+        Tuple of (success: bool, token: Optional[str])
+    """
+    print("\n🔍 Detecting execution environment...")
+    
+    # Check environment
+    try:
+        import notebookutils  # type: ignore
+        env_type = "Microsoft Fabric Notebook"
+    except ImportError:
+        try:
+            import google.colab
+            env_type = "Google Colab"
+        except ImportError:
+            # For all other environments (VS Code, local Python, etc.)
+            # we'll treat as local and try Azure CLI first
+            env_type = "Local/VS Code Environment"
+    
+    print(f"📍 Environment: {env_type}")
+    
+    token = get_token()
+    if token:
+        print(f"✅ Authentication successful for {env_type}")
+        return True, token
+    else:
+        print(f"❌ Authentication failed for {env_type}")
+        return False, None
+
+
+# For backward compatibility - expose the same interface as before
+def get_storage_token() -> str:
+    """
+    Backward compatible method - returns token or placeholder
+    """
+    token = get_token()
+    return token if token else "PLACEHOLDER_TOKEN_TOKEN_NOT_AVAILABLE"
+
+
+# Example usage function for testing
+def test_authentication():
+    """
+    Test authentication in current environment
+    """
+    print("=" * 60)
+    print("🧪 TESTING DUCKRUN AUTHENTICATION")
+    print("=" * 60)
+    
+    success, token = authenticate_for_environment()
+    
+    if success:
+        print("\n✅ Authentication test successful!")
+        print(f"Token length: {len(token) if token else 0} characters")
+        print(f"Token starts with: {token[:20] if token else 'None'}...")
+    else:
+        print("\n❌ Authentication test failed!")
+        print("Please check your Azure setup and permissions.")
+    
+    print("=" * 60)
+    return success

{duckrun-0.2.7 → duckrun-0.2.9}/duckrun/core.py

@@ -82,6 +82,15 @@ class Duckrun:
         
         self.con = duckdb.connect()
         self.con.sql("SET preserve_insertion_order = false")
+        
+        # Configure Azure transport for Colab (fixes SSL cert issues)
+        try:
+            import google.colab  # type: ignore
+            self.con.sql("SET azure_transport_option_type = 'curl'")
+            print("🔧 Colab detected - using curl transport for Azure")
+        except ImportError:
+            pass  # Not in Colab, use default transport
+        
         self._attach_lakehouse()
 
     @classmethod
@@ -196,18 +205,19 @@ class Duckrun:
         print(f"🔍 Resolving '{workspace_name}' workspace and '{lakehouse_name}' lakehouse to GUIDs (workspace has spaces)...")
         
         try:
-            # Get authentication token (try notebook environment first, then azure-identity)
+            # Get authentication token using enhanced auth system
+            from .auth import get_fabric_api_token
+            token = get_fabric_api_token()
+            if not token:
+                raise ValueError("Failed to obtain Fabric API token")
+                
+            # Try to get current workspace ID if in notebook environment
+            current_workspace_id = None
             try:
                 import notebookutils  # type: ignore
-                token = notebookutils.credentials.getToken("pbi")
                 current_workspace_id = notebookutils.runtime.context.get("workspaceId")
             except ImportError:
-                current_workspace_id = None
-                # Fallback to azure-identity for external environments
-                from azure.identity import AzureCliCredential, InteractiveBrowserCredential, ChainedTokenCredential
-                credential = ChainedTokenCredential(AzureCliCredential(), InteractiveBrowserCredential())
-                token_obj = credential.get_token("https://api.fabric.microsoft.com/.default")
-                token = token_obj.token
+                pass  # Not in notebook environment
             
             # Resolve workspace name to ID 
             if current_workspace_id:
@@ -302,19 +312,23 @@ class Duckrun:
         return WorkspaceConnection(workspace_name)
 
     def _get_storage_token(self):
-        return os.environ.get("AZURE_STORAGE_TOKEN", "PLACEHOLDER_TOKEN_TOKEN_NOT_AVAILABLE")
+        from .auth import get_storage_token
+        return get_storage_token()
 
     def _create_onelake_secret(self):
         token = self._get_storage_token()
         if token != "PLACEHOLDER_TOKEN_TOKEN_NOT_AVAILABLE":
             self.con.sql(f"CREATE OR REPLACE SECRET onelake (TYPE AZURE, PROVIDER ACCESS_TOKEN, ACCESS_TOKEN '{token}')")
         else:
-            print("Authenticating with Azure (trying CLI, will fallback to browser if needed)...")
-            from azure.identity import AzureCliCredential, InteractiveBrowserCredential, ChainedTokenCredential
-            credential = ChainedTokenCredential(AzureCliCredential(), InteractiveBrowserCredential())
-            token = credential.get_token("https://storage.azure.com/.default")
-            os.environ["AZURE_STORAGE_TOKEN"] = token.token
-            self.con.sql("CREATE OR REPLACE PERSISTENT SECRET onelake (TYPE azure, PROVIDER credential_chain, CHAIN 'cli', ACCOUNT_NAME 'onelake')")
+            # Enhanced authentication - try all methods
+            from .auth import get_token
+            token = get_token()
+            if token:
+                os.environ["AZURE_STORAGE_TOKEN"] = token
+                self.con.sql(f"CREATE OR REPLACE SECRET onelake (TYPE AZURE, PROVIDER ACCESS_TOKEN, ACCESS_TOKEN '{token}')")
+            else:
+                # Final fallback to persistent secret
+                self.con.sql("CREATE OR REPLACE PERSISTENT SECRET onelake (TYPE azure, PROVIDER credential_chain, CHAIN 'cli', ACCOUNT_NAME 'onelake')")
 
     def _discover_tables_fast(self) -> List[Tuple[str, str]]:
         """
@@ -326,12 +340,12 @@ class Duckrun:
         """
         token = self._get_storage_token()
         if token == "PLACEHOLDER_TOKEN_TOKEN_NOT_AVAILABLE":
-            print("Authenticating with Azure for table discovery (trying CLI, will fallback to browser if needed)...")
-            from azure.identity import AzureCliCredential, InteractiveBrowserCredential, ChainedTokenCredential
-            credential = ChainedTokenCredential(AzureCliCredential(), InteractiveBrowserCredential())
-            token_obj = credential.get_token("https://storage.azure.com/.default")
-            token = token_obj.token
-            os.environ["AZURE_STORAGE_TOKEN"] = token
+            print("Authenticating with Azure for table discovery (detecting environment automatically)...")
+            from .auth import get_token
+            token = get_token()
+            if not token:
+                print("❌ Failed to authenticate for table discovery")
+                return []
         
         url = f"abfss://{self.workspace}@{self.storage_account}.dfs.fabric.microsoft.com/"
         store = AzureStore.from_url(url, bearer_token=token)
@@ -579,19 +593,22 @@ class Duckrun:
             List of lakehouse names
         """
         try:
-            # Try to get token from notebook environment first
+            # Get authentication token using enhanced auth system
+            from .auth import get_fabric_api_token
+            token = get_fabric_api_token()
+            if not token:
+                print("❌ Failed to authenticate for listing lakehouses")
+                return []
+            
+            # Try to get current workspace ID if in notebook environment
+            workspace_id = None
             try:
                 import notebookutils  # type: ignore
-                token = notebookutils.credentials.getToken("pbi")
                 workspace_id = notebookutils.runtime.context.get("workspaceId")
             except ImportError:
-                # Fallback to azure-identity
-                print("Getting authentication token...")
-                from azure.identity import AzureCliCredential, InteractiveBrowserCredential, ChainedTokenCredential
-                credential = ChainedTokenCredential(AzureCliCredential(), InteractiveBrowserCredential())
-                token_obj = credential.get_token("https://api.fabric.microsoft.com/.default")
-                token = token_obj.token
-                
+                pass  # Not in notebook environment
+            
+            if not workspace_id:
                 # Get workspace ID by name
                 workspace_id = self._get_workspace_id_by_name(token, self.workspace)
                 if not workspace_id:
@@ -626,19 +643,22 @@ class Duckrun:
             True if lakehouse exists or was created successfully, False otherwise
         """
         try:
-            # Try to get token from notebook environment first
+            # Get authentication token using enhanced auth system
+            from .auth import get_fabric_api_token
+            token = get_fabric_api_token()
+            if not token:
+                print("❌ Failed to authenticate for lakehouse creation")
+                return False
+            
+            # Try to get current workspace ID if in notebook environment
+            workspace_id = None
             try:
                 import notebookutils  # type: ignore
-                token = notebookutils.credentials.getToken("pbi")
                 workspace_id = notebookutils.runtime.context.get("workspaceId")
             except ImportError:
-                # Fallback to azure-identity
-                print("Getting authentication token...")
-                from azure.identity import AzureCliCredential, InteractiveBrowserCredential, ChainedTokenCredential
-                credential = ChainedTokenCredential(AzureCliCredential(), InteractiveBrowserCredential())
-                token_obj = credential.get_token("https://api.fabric.microsoft.com/.default")
-                token = token_obj.token
-                
+                pass  # Not in notebook environment
+            
+            if not workspace_id:
                 # Get workspace ID by name
                 workspace_id = self._get_workspace_id_by_name(token, self.workspace)
                 if not workspace_id:
@@ -676,6 +696,45 @@ class Duckrun:
             print(f"❌ Error creating lakehouse '{lakehouse_name}': {e}")
             return False
 
+    def deploy(self, bim_url: str, dataset_name: Optional[str] = None, 
+               wait_seconds: int = 5) -> int:
+        """
+        Deploy a semantic model from a BIM file using DirectLake mode.
+        
+        Args:
+            bim_url: URL to the BIM file (e.g., GitHub raw URL)
+            dataset_name: Name for the semantic model (default: lakehouse_schema)
+            wait_seconds: Seconds to wait for permission propagation (default: 5)
+        
+        Returns:
+            1 for success, 0 for failure
+        
+        Examples:
+            dr = Duckrun.connect("My Workspace/My Lakehouse.lakehouse/dbo")
+            
+            # Deploy with auto-generated name
+            dr.deploy("https://raw.githubusercontent.com/.../model.bim")
+            
+            # Deploy with custom name
+            dr.deploy("https://raw.githubusercontent.com/.../model.bim", 
+                     dataset_name="Sales Model")
+        """
+        from .semantic_model import deploy_semantic_model
+        
+        # Auto-generate dataset name if not provided
+        if dataset_name is None:
+            dataset_name = f"{self.lakehouse_name}_{self.schema}"
+        
+        # Call the deployment function (DirectLake only)
+        return deploy_semantic_model(
+            workspace_name_or_id=self.workspace,
+            lakehouse_name_or_id=self.lakehouse_name,
+            schema_name=self.schema,
+            dataset_name=dataset_name,
+            bim_url=bim_url,
+            wait_seconds=wait_seconds
+        )
+
     def _get_workspace_id_by_name(self, token: str, workspace_name: str) -> Optional[str]:
         """Helper method to get workspace ID from name"""
         try:
@@ -718,28 +777,18 @@ class WorkspaceConnection:
             List of lakehouse names
         """
         try:
-            # Try to get token from notebook environment first
-            try:
-                import notebookutils  # type: ignore
-                token = notebookutils.credentials.getToken("pbi")
-                # Always resolve workspace name to ID, even in notebook environment
-                workspace_id = self._get_workspace_id_by_name(token, self.workspace_name)
-                if not workspace_id:
-                    print(f"Workspace '{self.workspace_name}' not found")
-                    return []
-            except ImportError:
-                # Fallback to azure-identity
-                print("Getting authentication token...")
-                from azure.identity import AzureCliCredential, InteractiveBrowserCredential, ChainedTokenCredential
-                credential = ChainedTokenCredential(AzureCliCredential(), InteractiveBrowserCredential())
-                token_obj = credential.get_token("https://api.fabric.microsoft.com/.default")
-                token = token_obj.token
-                
-                # Get workspace ID by name
-                workspace_id = self._get_workspace_id_by_name(token, self.workspace_name)
-                if not workspace_id:
-                    print(f"Workspace '{self.workspace_name}' not found")
-                    return []
+            # Get authentication token using enhanced auth system
+            from .auth import get_fabric_api_token
+            token = get_fabric_api_token()
+            if not token:
+                print("❌ Failed to authenticate for listing lakehouses")
+                return []
+            
+            # Always resolve workspace name to ID, even in notebook environment
+            workspace_id = self._get_workspace_id_by_name(token, self.workspace_name)
+            if not workspace_id:
+                print(f"Workspace '{self.workspace_name}' not found")
+                return []
             
             # List lakehouses
             url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/lakehouses"
@@ -768,28 +817,18 @@ class WorkspaceConnection:
             True if lakehouse exists or was created successfully, False otherwise
         """
         try:
-            # Try to get token from notebook environment first
-            try:
-                import notebookutils  # type: ignore
-                token = notebookutils.credentials.getToken("pbi")
-                # Always resolve workspace name to ID, even in notebook environment
-                workspace_id = self._get_workspace_id_by_name(token, self.workspace_name)
-                if not workspace_id:
-                    print(f"Workspace '{self.workspace_name}' not found")
-                    return False
-            except ImportError:
-                # Fallback to azure-identity
-                print("Getting authentication token...")
-                from azure.identity import AzureCliCredential, InteractiveBrowserCredential, ChainedTokenCredential
-                credential = ChainedTokenCredential(AzureCliCredential(), InteractiveBrowserCredential())
-                token_obj = credential.get_token("https://api.fabric.microsoft.com/.default")
-                token = token_obj.token
-                
-                # Get workspace ID by name
-                workspace_id = self._get_workspace_id_by_name(token, self.workspace_name)
-                if not workspace_id:
-                    print(f"Workspace '{self.workspace_name}' not found")
-                    return False
+            # Get authentication token using enhanced auth system
+            from .auth import get_fabric_api_token
+            token = get_fabric_api_token()
+            if not token:
+                print("❌ Failed to authenticate for lakehouse creation")
+                return False
+            
+            # Always resolve workspace name to ID, even in notebook environment
+            workspace_id = self._get_workspace_id_by_name(token, self.workspace_name)
+            if not workspace_id:
+                print(f"Workspace '{self.workspace_name}' not found")
+                return False
             
             # Check if lakehouse already exists
             url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/lakehouses"