duckrun 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

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/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/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"

duckrun/files.py

@@ -41,15 +41,15 @@ def copy(duckrun_instance, local_folder: str, remote_folder: str,
         print(f"❌ Path is not a directory: {local_folder}")
         return False
         
-    # Get Azure token
+    # Get Azure token using enhanced auth system
+    from .auth import get_token
     token = duckrun_instance._get_storage_token()
     if token == "PLACEHOLDER_TOKEN_TOKEN_NOT_AVAILABLE":
-        print("Authenticating with Azure for file upload (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 file upload (detecting environment automatically)...")
+        token = get_token()
+        if not token:
+            print("❌ Failed to authenticate for file upload")
+            return False
     
     # Setup OneLake Files URL (use correct format without .Lakehouse suffix)
     files_base_url = duckrun_instance.files_base_url
@@ -150,15 +150,15 @@ def download(duckrun_instance, remote_folder: str = "", local_folder: str = "./d
         # Download only CSV files from a specific subfolder
         dr.download("daily_reports", "./reports", ['.csv'])
     """
-    # Get Azure token
+    # Get Azure token using enhanced auth system
+    from .auth import get_token
     token = duckrun_instance._get_storage_token()
     if token == "PLACEHOLDER_TOKEN_TOKEN_NOT_AVAILABLE":
-        print("Authenticating with Azure for file download (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 file download (detecting environment automatically)...")
+        token = get_token()
+        if not token:
+            print("❌ Failed to authenticate for file download")
+            return False
     
     # Setup OneLake Files URL (use correct format without .Lakehouse suffix)
     files_base_url = duckrun_instance.files_base_url

duckrun/runner.py

@@ -15,7 +15,7 @@ def _build_write_deltalake_args(path, df, mode, schema_mode=None, partition_by=N
     """
     Build arguments for write_deltalake based on requirements:
     - If schema_mode='merge': use rust engine (no row group params)
-    - Otherwise: use pyarrow engine with row group optimization
+    - Otherwise: use pyarrow engine with row group optimization (if supported)
     """
     args = {
         'table_or_uri': path,
@@ -33,10 +33,17 @@ def _build_write_deltalake_args(path, df, mode, schema_mode=None, partition_by=N
         args['schema_mode'] = 'merge'
         args['engine'] = 'rust'
     else:
-        # Use pyarrow engine with row group optimization (default)
-        args['max_rows_per_file'] = RG
-        args['max_rows_per_group'] = RG
-        args['min_rows_per_group'] = RG
+        # Try to use pyarrow engine with row group optimization
+        # Check if row group parameters are supported by inspecting function signature
+        import inspect
+        sig = inspect.signature(write_deltalake)
+        
+        if 'max_rows_per_file' in sig.parameters:
+            # Older deltalake version - use row group optimization
+            args['max_rows_per_file'] = RG
+            args['max_rows_per_group'] = RG
+            args['min_rows_per_group'] = RG
+        # For newer versions, just use default parameters
     
     return args
 

duckrun/semantic_model.py

@@ -0,0 +1,434 @@
+"""
+Semantic Model Deployer - DirectLake mode for Fabric Lakehouses
+Uses duckrun's authentication. Works anywhere duckrun works.
+"""
+
+import requests
+import json
+import time
+import base64
+
+
+class FabricRestClient:
+    """Fabric REST API client using duckrun's authentication."""
+    
+    def __init__(self):
+        self.base_url = "https://api.fabric.microsoft.com"
+        self.token = None
+        self._get_token()
+    
+    def _get_token(self):
+        """Get Fabric API token using duckrun's auth module"""
+        from duckrun.auth import get_fabric_api_token
+        self.token = get_fabric_api_token()
+        if not self.token:
+            raise Exception("Failed to get Fabric API token")
+    
+    def _get_headers(self):
+        return {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json"
+        }
+    
+    def get(self, endpoint: str):
+        url = f"{self.base_url}{endpoint}"
+        response = requests.get(url, headers=self._get_headers())
+        response.raise_for_status()
+        return response
+    
+    def post(self, endpoint: str, json: dict = None):
+        url = f"{self.base_url}{endpoint}"
+        response = requests.post(url, headers=self._get_headers(), json=json)
+        response.raise_for_status()
+        return response
+
+
+def get_workspace_id(workspace_name_or_id, client):
+    """Get workspace ID by name or validate if already a GUID"""
+    import re
+    
+    # Check if input is already a GUID
+    guid_pattern = re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$', re.IGNORECASE)
+    if guid_pattern.match(workspace_name_or_id):
+        # It's already a GUID, verify it exists
+        try:
+            response = client.get(f"/v1/workspaces/{workspace_name_or_id}")
+            workspace_name = response.json().get('displayName', workspace_name_or_id)
+            print(f"✓ Found workspace: {workspace_name}")
+            return workspace_name_or_id
+        except:
+            raise ValueError(f"Workspace with ID '{workspace_name_or_id}' not found")
+    
+    # It's a name, search for it
+    response = client.get("/v1/workspaces")
+    workspaces = response.json().get('value', [])
+    
+    workspace_match = next((ws for ws in workspaces if ws.get('displayName') == workspace_name_or_id), None)
+    if not workspace_match:
+        raise ValueError(f"Workspace '{workspace_name_or_id}' not found")
+    
+    workspace_id = workspace_match['id']
+    print(f"✓ Found workspace: {workspace_name_or_id}")
+    return workspace_id
+
+
+def get_lakehouse_id(lakehouse_name_or_id, workspace_id, client):
+    """Get lakehouse ID by name or validate if already a GUID"""
+    import re
+    
+    # Check if input is already a GUID
+    guid_pattern = re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$', re.IGNORECASE)
+    if guid_pattern.match(lakehouse_name_or_id):
+        # It's already a GUID, verify it exists
+        try:
+            response = client.get(f"/v1/workspaces/{workspace_id}/lakehouses")
+            items = response.json().get('value', [])
+            lakehouse_match = next((item for item in items if item.get('id') == lakehouse_name_or_id), None)
+            if lakehouse_match:
+                lakehouse_name = lakehouse_match.get('displayName', lakehouse_name_or_id)
+                print(f"✓ Found lakehouse: {lakehouse_name}")
+                return lakehouse_name_or_id
+            else:
+                raise ValueError(f"Lakehouse with ID '{lakehouse_name_or_id}' not found")
+        except Exception as e:
+            raise ValueError(f"Lakehouse with ID '{lakehouse_name_or_id}' not found: {e}")
+    
+    # It's a name, search for it
+    response = client.get(f"/v1/workspaces/{workspace_id}/lakehouses")
+    items = response.json().get('value', [])
+    
+    lakehouse_match = next((item for item in items if item.get('displayName') == lakehouse_name_or_id), None)
+    if not lakehouse_match:
+        raise ValueError(f"Lakehouse '{lakehouse_name_or_id}' not found")
+    
+    lakehouse_id = lakehouse_match['id']
+    print(f"✓ Found lakehouse: {lakehouse_name_or_id}")
+    return lakehouse_id
+
+
+def get_dataset_id(dataset_name, workspace_id, client):
+    """Get dataset ID by name"""
+    response = client.get(f"/v1/workspaces/{workspace_id}/semanticModels")
+    items = response.json().get('value', [])
+    
+    dataset_match = next((item for item in items if item.get('displayName') == dataset_name), None)
+    if not dataset_match:
+        raise ValueError(f"Dataset '{dataset_name}' not found")
+    
+    return dataset_match['id']
+
+
+def check_dataset_exists(dataset_name, workspace_id, client):
+    """Check if dataset already exists"""
+    try:
+        get_dataset_id(dataset_name, workspace_id, client)
+        print(f"⚠️  Dataset '{dataset_name}' already exists")
+        return True
+    except:
+        print(f"✓ Dataset name '{dataset_name}' is available")
+        return False
+
+
+def refresh_dataset(dataset_name, workspace_id, client, dataset_id=None):
+    """Refresh a dataset and monitor progress using Power BI API"""
+    
+    # If dataset_id not provided, look it up by name
+    if not dataset_id:
+        dataset_id = get_dataset_id(dataset_name, workspace_id, client)
+    
+    payload = {
+        "type": "full",
+        "commitMode": "transactional",
+        "maxParallelism": 10,
+        "retryCount": 2,
+        "objects": []
+    }
+    
+    # Use Power BI API for refresh (not Fabric API)
+    powerbi_url = f"https://api.powerbi.com/v1.0/myorg/datasets/{dataset_id}/refreshes"
+    headers = client._get_headers()
+    
+    response = requests.post(powerbi_url, headers=headers, json=payload)
+    
+    if response.status_code in [200, 202]:
+        print(f"✓ Refresh initiated")
+        
+        # For 202, get the refresh_id from the Location header
+        if response.status_code == 202:
+            location = response.headers.get('Location')
+            if location:
+                refresh_id = location.split('/')[-1]
+                print("   Monitoring refresh progress...")
+                max_attempts = 60
+                for attempt in range(max_attempts):
+                    time.sleep(5)
+                    
+                    # Check refresh status using Power BI API
+                    status_url = f"https://api.powerbi.com/v1.0/myorg/datasets/{dataset_id}/refreshes/{refresh_id}"
+                    status_response = requests.get(status_url, headers=headers)
+                    status_response.raise_for_status()
+                    status = status_response.json().get('status')
+                    
+                    if status == 'Completed':
+                        print(f"✓ Refresh completed successfully")
+                        return
+                    elif status == 'Failed':
+                        error = status_response.json().get('serviceExceptionJson', '')
+                        raise Exception(f"Refresh failed: {error}")
+                    elif status == 'Cancelled':
+                        raise Exception("Refresh was cancelled")
+                    
+                    if attempt % 6 == 0:
+                        print(f"   Status: {status}...")
+                
+                raise Exception(f"Refresh timed out")
+    else:
+        response.raise_for_status()
+
+
+def download_bim_from_github(url):
+    """Download BIM file from URL"""
+    print(f"Downloading BIM file...")
+    response = requests.get(url)
+    response.raise_for_status()
+    bim_content = response.json()
+    print(f"✓ BIM file downloaded")
+    print(f"  - Tables: {len(bim_content.get('model', {}).get('tables', []))}")
+    print(f"  - Relationships: {len(bim_content.get('model', {}).get('relationships', []))}")
+    return bim_content
+
+
+def update_bim_for_directlake(bim_content, workspace_id, lakehouse_id, schema_name):
+    """Update BIM file for DirectLake mode"""
+    
+    new_url = f"https://onelake.dfs.fabric.microsoft.com/{workspace_id}/{lakehouse_id}"
+    expression_name = None
+    
+    # Update or create DirectLake expression
+    if 'model' in bim_content and 'expressions' in bim_content['model']:
+        for expr in bim_content['model']['expressions']:
+            if 'DirectLake' in expr['name'] or expr.get('kind') == 'm':
+                expression_name = expr['name']
+                expr['expression'] = [
+                    "let",
+                    f"    Source = AzureStorage.DataLake(\"{new_url}\", [HierarchicalNavigation=true])",
+                    "in",
+                    "    Source"
+                ]
+                break
+    
+    if not expression_name:
+        expression_name = f"DirectLake - {schema_name}"
+        if 'expressions' not in bim_content['model']:
+            bim_content['model']['expressions'] = []
+        
+        bim_content['model']['expressions'].append({
+            "name": expression_name,
+            "kind": "m",
+            "expression": [
+                "let",
+                f"    Source = AzureStorage.DataLake(\"{new_url}\", [HierarchicalNavigation=true])",
+                "in",
+                "    Source"
+            ],
+            "lineageTag": f"directlake-{schema_name}-source"
+        })
+    
+    # Update table partitions for DirectLake
+    if 'tables' in bim_content['model']:
+        for table in bim_content['model']['tables']:
+            if 'partitions' in table:
+                for partition in table['partitions']:
+                    if 'source' in partition:
+                        partition['mode'] = 'directLake'
+                        partition['source'] = {
+                            "type": "entity",
+                            "entityName": partition['source'].get('entityName', table['name']),
+                            "expressionSource": expression_name,
+                            "schemaName": schema_name
+                        }
+    
+    print(f"✓ Updated BIM for DirectLake")
+    print(f"  - OneLake URL: {new_url}")
+    print(f"  - Schema: {schema_name}")
+    
+    return bim_content
+
+
+def create_dataset_from_bim(dataset_name, bim_content, workspace_id, client):
+    """Create semantic model from BIM using Fabric REST API and return the dataset ID"""
+    # Convert to base64
+    bim_json = json.dumps(bim_content, indent=2)
+    bim_base64 = base64.b64encode(bim_json.encode('utf-8')).decode('utf-8')
+    
+    pbism_content = {"version": "1.0"}
+    pbism_json = json.dumps(pbism_content)
+    pbism_base64 = base64.b64encode(pbism_json.encode('utf-8')).decode('utf-8')
+    
+    payload = {
+        "displayName": dataset_name,
+        "definition": {
+            "parts": [
+                {
+                    "path": "model.bim",
+                    "payload": bim_base64,
+                    "payloadType": "InlineBase64"
+                },
+                {
+                    "path": "definition.pbism",
+                    "payload": pbism_base64,
+                    "payloadType": "InlineBase64"
+                }
+            ]
+        }
+    }
+    
+    response = client.post(
+        f"/v1/workspaces/{workspace_id}/semanticModels",
+        json=payload
+    )
+    
+    print(f"✓ Semantic model created")
+    
+    # Handle long-running operation and return the dataset ID
+    if response.status_code == 202:
+        operation_id = response.headers.get('x-ms-operation-id')
+        print(f"   Waiting for operation to complete...")
+        
+        max_attempts = 30
+        for attempt in range(max_attempts):
+            time.sleep(2)
+            
+            # Get operation result (not just status)
+            result_response = client.get(f"/v1/operations/{operation_id}/result")
+            
+            # Check if operation is complete by getting the status
+            status_response = client.get(f"/v1/operations/{operation_id}")
+            status = status_response.json().get('status')
+            
+            if status == 'Succeeded':
+                print(f"✓ Operation completed")
+                # Return the created dataset ID from the result
+                result_data = result_response.json()
+                dataset_id = result_data.get('id')
+                if dataset_id:
+                    return dataset_id
+                else:
+                    # Fallback: search for the dataset by name
+                    return get_dataset_id(dataset_name, workspace_id, client)
+            elif status == 'Failed':
+                error = status_response.json().get('error', {})
+                raise Exception(f"Operation failed: {error.get('message')}")
+            elif attempt == max_attempts - 1:
+                raise Exception(f"Operation timed out")
+    
+    # For non-async responses (status 200/201)
+    result_data = response.json()
+    dataset_id = result_data.get('id')
+    if dataset_id:
+        return dataset_id
+    else:
+        # Fallback: search for the dataset by name
+        return get_dataset_id(dataset_name, workspace_id, client)
+
+
+def deploy_semantic_model(workspace_name_or_id, lakehouse_name_or_id, schema_name, dataset_name, 
+                         bim_url, wait_seconds=5):
+    """
+    Deploy a semantic model using DirectLake mode.
+    
+    Args:
+        workspace_name_or_id: Name or GUID of the target workspace
+        lakehouse_name_or_id: Name or GUID of the lakehouse
+        schema_name: Schema name (e.g., 'dbo', 'staging')
+        dataset_name: Name for the semantic model
+        bim_url: URL to the BIM file
+        wait_seconds: Seconds to wait before refresh (default: 5)
+    
+    Returns:
+        1 for success, 0 for failure
+    
+    Examples:
+        dr = Duckrun.connect("My Workspace/My Lakehouse.lakehouse/dbo")
+        dr.deploy("https://raw.githubusercontent.com/.../model.bim")
+    """
+    print("=" * 70)
+    print("Semantic Model Deployment (DirectLake)")
+    print("=" * 70)
+    
+    client = FabricRestClient()
+    
+    try:
+        # Step 1: Get workspace ID
+        print("\n[Step 1/6] Getting workspace information...")
+        workspace_id = get_workspace_id(workspace_name_or_id, client)
+        
+        # Step 2: Check if dataset exists
+        print(f"\n[Step 2/6] Checking if dataset '{dataset_name}' exists...")
+        dataset_exists = check_dataset_exists(dataset_name, workspace_id, client)
+        
+        if dataset_exists:
+            print(f"\n✓ Dataset exists - refreshing...")
+            
+            if wait_seconds > 0:
+                print(f"   Waiting {wait_seconds} seconds...")
+                time.sleep(wait_seconds)
+            
+            print("\n[Step 6/6] Refreshing semantic model...")
+            refresh_dataset(dataset_name, workspace_id, client)
+            
+            print("\n" + "=" * 70)
+            print("🎉 Refresh Completed!")
+            print("=" * 70)
+            print(f"Dataset: {dataset_name}")
+            print("=" * 70)
+            return 1
+        
+        # Step 3: Get lakehouse ID
+        print(f"\n[Step 3/6] Finding lakehouse...")
+        lakehouse_id = get_lakehouse_id(lakehouse_name_or_id, workspace_id, client)
+        
+        # Step 4: Download and update BIM
+        print("\n[Step 4/6] Downloading and configuring BIM file...")
+        bim_content = download_bim_from_github(bim_url)
+        
+        modified_bim = update_bim_for_directlake(bim_content, workspace_id, lakehouse_id, schema_name)
+        modified_bim['name'] = dataset_name
+        modified_bim['id'] = dataset_name
+        
+        # Step 5: Deploy and get the dataset ID
+        print("\n[Step 5/6] Deploying semantic model...")
+        dataset_id = create_dataset_from_bim(dataset_name, modified_bim, workspace_id, client)
+        print(f"   Dataset ID: {dataset_id}")
+        
+        if wait_seconds > 0:
+            print(f"   Waiting {wait_seconds} seconds before refresh...")
+            time.sleep(wait_seconds)
+        
+        # Step 6: Refresh using the dataset ID returned from creation
+        print("\n[Step 6/6] Refreshing semantic model...")
+        refresh_dataset(dataset_name, workspace_id, client, dataset_id=dataset_id)
+        
+        print("\n" + "=" * 70)
+        print("🎉 Deployment Completed!")
+        print("=" * 70)
+        print(f"Dataset: {dataset_name}")
+        print(f"Workspace: {workspace_name_or_id}")
+        print(f"Lakehouse: {lakehouse_name_or_id}")
+        print(f"Schema: {schema_name}")
+        print("=" * 70)
+        
+        return 1
+        
+    except Exception as e:
+        print("\n" + "=" * 70)
+        print("❌ Deployment Failed")
+        print("=" * 70)
+        print(f"Error: {str(e)}")
+        print("\n💡 Troubleshooting:")
+        print(f"  - Verify workspace '{workspace_name_or_id}' exists")
+        print(f"  - Verify lakehouse '{lakehouse_name_or_id}' exists")
+        print(f"  - Ensure tables exist in '{schema_name}' schema")
+        print(f"  - Check tables are in Delta format")
+        print("=" * 70)
+        return 0

duckrun/stats.py

@@ -147,7 +147,20 @@ def get_stats(duckrun_instance, source: str):
         
         try:
             dt = DeltaTable(table_path)
-            xx = dt.get_add_actions(flatten=True).to_pydict()
+            add_actions = dt.get_add_actions(flatten=True)
+            
+            # Convert to dict - compatible with both old and new deltalake versions
+            # Try to_pydict() first (old versions), fall back to to_pylist() (new versions)
+            try:
+                xx = add_actions.to_pydict()
+            except AttributeError:
+                # New version with arro3: use to_pylist() and convert to dict of lists
+                records = add_actions.to_pylist()
+                if records:
+                    # Convert list of dicts to dict of lists
+                    xx = {key: [record[key] for record in records] for key in records[0].keys()}
+                else:
+                    xx = {}
             
             # Check if VORDER exists
             vorder = 'tags.VORDER' in xx.keys()

duckrun/writer.py

@@ -1,18 +1,36 @@
 """
 Delta Lake writer functionality for duckrun - Spark-style write API
 """
-from deltalake import DeltaTable, write_deltalake
+from deltalake import DeltaTable, write_deltalake, __version__ as deltalake_version
 
 
 # Row Group configuration for optimal Delta Lake performance
 RG = 8_000_000
 
+# Check deltalake version once at module load
+# Version 0.18.x and 0.19.x support engine parameter and row group optimization
+# Version 0.20+ removed these features (rust only, no row groups)
+_DELTALAKE_VERSION = tuple(map(int, deltalake_version.split('.')[:2]))
+_IS_OLD_DELTALAKE = _DELTALAKE_VERSION < (0, 20)
+
 
 def _build_write_deltalake_args(path, df, mode, schema_mode=None, partition_by=None):
     """
-    Build arguments for write_deltalake based on requirements:
-    - If schema_mode='merge': use rust engine (no row group params)
-    - Otherwise: use pyarrow engine with row group optimization
+    Build arguments for write_deltalake based on requirements and version:
+    
+    deltalake 0.18.2 - 0.19.x:
+    - Has 'engine' parameter (defaults to 'pyarrow')
+    - Has max_rows_per_file/max_rows_per_group/min_rows_per_group for optimization
+    - When mergeSchema=True: must set schema_mode='merge' + engine='rust', NO row group params
+    - When mergeSchema=False: use row group params, DON'T set engine (pyarrow is default)
+    
+    deltalake 0.20+:
+    - Does NOT have 'engine' parameter (everything is rust, pyarrow deprecated)
+    - Does NOT have max_rows_per_file (row group optimization removed)
+    - When mergeSchema=True: must set schema_mode='merge'
+    - When mergeSchema=False: just write normally (no special params)
+    
+    Uses version detection for simpler logic.
     """
     args = {
         'table_or_uri': path,
@@ -24,16 +42,24 @@ def _build_write_deltalake_args(path, df, mode, schema_mode=None, partition_by=N
     if partition_by:
         args['partition_by'] = partition_by
     
-    # Engine selection based on schema_mode
     if schema_mode == 'merge':
-        # Use rust engine for schema merging (no row group params supported)
+        # Schema merging mode - must explicitly set schema_mode='merge'
         args['schema_mode'] = 'merge'
-        args['engine'] = 'rust'
+        
+        if _IS_OLD_DELTALAKE:
+            # deltalake 0.18.2-0.19.x: must also set engine='rust' for schema merging
+            # Do NOT use row group params (they conflict with rust engine)
+            args['engine'] = 'rust'
+        # For version 0.20+: just schema_mode='merge' is enough, rust is default
     else:
-        # Use pyarrow engine with row group optimization (default)
-        args['max_rows_per_file'] = RG
-        args['max_rows_per_group'] = RG
-        args['min_rows_per_group'] = RG
+        # Normal write mode (no schema merging)
+        if _IS_OLD_DELTALAKE:
+            # deltalake 0.18.2-0.19.x: use row group optimization
+            # DON'T set engine parameter - pyarrow is the default and works with row groups
+            args['max_rows_per_file'] = RG
+            args['max_rows_per_group'] = RG
+            args['min_rows_per_group'] = RG
+        # For version 0.20+: no optimization available (rust by default, no row group params supported)
     
     return args
 
@@ -106,7 +132,18 @@ class DeltaWriter:
             partition_by=self._partition_by
         )
         
-        engine_info = f" (engine=rust, schema_mode=merge)" if self._schema_mode == 'merge' else " (engine=pyarrow)"
+        # Prepare info message based on version and settings
+        if self._schema_mode == 'merge':
+            if _IS_OLD_DELTALAKE:
+                engine_info = " (engine=rust, schema_mode=merge)"
+            else:
+                engine_info = " (schema_mode=merge, rust by default)"
+        else:
+            if _IS_OLD_DELTALAKE:
+                engine_info = " (engine=pyarrow, optimized row groups)"
+            else:
+                engine_info = " (engine=rust by default)"
+        
         partition_info = f" partitioned by {self._partition_by}" if self._partition_by else ""
         print(f"Writing to Delta table: {schema}.{table} (mode={self._mode}){engine_info}{partition_info}")
         

{duckrun-0.2.7.dist-info → duckrun-0.2.9.dist-info}/METADATA

@@ -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.9.dist-info/RECORD

@@ -0,0 +1,14 @@
+duckrun/__init__.py,sha256=cTj6KQ6hKmgu1z7k9nhDcO5lct049luxjx1V0QnymCo,235
+duckrun/auth.py,sha256=qPaLQ7InlV9leA9r6E6VEeYavFFoBi0zSN8m_l1aoQs,9545
+duckrun/core.py,sha256=CrWMgA1QHvVF2AAlTlBlQ7VfKsuakcqZa4VuX2WJmik,39279
+duckrun/files.py,sha256=Fvdjg3DyHJzIVzKo8M_j-eGz4zU61lOB38Y_onbQJkI,10137
+duckrun/lakehouse.py,sha256=j--Z3zo8AOWt1GF9VzRosmmTAy6ey2D0LVubti58twU,14109
+duckrun/runner.py,sha256=yrDxfy1RVkb8iK9GKGmIFZHzCvcO_0GVQlbng7Vw_iM,14171
+duckrun/semantic_model.py,sha256=jmTrS15WmhU3rQfdpLII1wm3EORdQfqQxOhqOSyXB_w,17305
+duckrun/stats.py,sha256=CXfb2DWF3PgOckelJooU0y-BAsNT9NFDfDYEmo0mUQQ,10473
+duckrun/writer.py,sha256=svUuPCYOhrz299NgnpTKhARKjfej0PxnoND2iPDSypk,8098
+duckrun-0.2.9.dist-info/licenses/LICENSE,sha256=-DeQQwdbCbkB4507ZF3QbocysB-EIjDtaLexvqRkGZc,1083
+duckrun-0.2.9.dist-info/METADATA,sha256=T4hEXLJELzqhPWDJtez42co8bNbaNgAabywoxFW0hC4,20623
+duckrun-0.2.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+duckrun-0.2.9.dist-info/top_level.txt,sha256=BknMEwebbUHrVAp3SC92ps8MPhK7XSYsaogTvi_DmEU,8
+duckrun-0.2.9.dist-info/RECORD,,

duckrun-0.2.7.dist-info/RECORD

@@ -1,12 +0,0 @@
-duckrun/__init__.py,sha256=XA85pL2vK1AkmBic8e7WxeqNvcd6SjFX4zsQpImDO6E,230
-duckrun/core.py,sha256=Y4-5H83Xw0mZa12QM5pcC7qOPidrDFASLcGIoUW3zwY,39394
-duckrun/files.py,sha256=piWRU5w9jHrW-wuV4Gf-SKY_jhFv9eflxgWO8AZCQTI,10495
-duckrun/lakehouse.py,sha256=j--Z3zo8AOWt1GF9VzRosmmTAy6ey2D0LVubti58twU,14109
-duckrun/runner.py,sha256=XsQqWlesFD2cuhH2gsQj3Astg0XN7xhW15WPmr8D65I,13797
-duckrun/stats.py,sha256=2FTqoQNVjD84-H1HjStHxZkOpAGKXS79M55B00pOlok,9804
-duckrun/writer.py,sha256=eWrGtDQTbXi8H3sSt2WucYTdEQUjK97KmQxzCbqAuMs,6221
-duckrun-0.2.7.dist-info/licenses/LICENSE,sha256=-DeQQwdbCbkB4507ZF3QbocysB-EIjDtaLexvqRkGZc,1083
-duckrun-0.2.7.dist-info/METADATA,sha256=fIwgvoj3Hw4ByOcwCmG87zpLF0qnlzK8GAotup5km40,19272
-duckrun-0.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-duckrun-0.2.7.dist-info/top_level.txt,sha256=BknMEwebbUHrVAp3SC92ps8MPhK7XSYsaogTvi_DmEU,8
-duckrun-0.2.7.dist-info/RECORD,,