duckrun 0.2.9.dev5__py3-none-any.whl → 0.2.10__py3-none-any.whl

duckrun/core.py

@@ -2,6 +2,8 @@ import duckdb
 import requests
 import os
 import importlib.util
+import json
+import time
 from deltalake import DeltaTable, write_deltalake
 from typing import List, Tuple, Union, Optional, Callable, Dict, Any
 from string import Template
@@ -702,8 +704,11 @@ class Duckrun:
         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)
+            bim_url: Can be:
+                - URL: "https://raw.githubusercontent.com/.../model.bim"
+                - Local file: "model.bim"
+                - Workspace/Model: "workspace_name/model_name"
+            dataset_name: Name for the semantic model (default: source model name if workspace/model format, else lakehouse_schema)
             wait_seconds: Seconds to wait for permission propagation (default: 5)
         
         Returns:
@@ -712,18 +717,28 @@ class Duckrun:
         Examples:
             dr = Duckrun.connect("My Workspace/My Lakehouse.lakehouse/dbo")
             
-            # Deploy with auto-generated name
-            dr.deploy("https://raw.githubusercontent.com/.../model.bim")
+            # Deploy from workspace/model (uses same name by default)
+            dr.deploy("Source Workspace/Source Model")  # Creates "Source Model"
             
             # Deploy with custom name
-            dr.deploy("https://raw.githubusercontent.com/.../model.bim", 
-                     dataset_name="Sales Model")
+            dr.deploy("Source Workspace/Source Model", dataset_name="Sales Model Copy")
+            
+            # Deploy from URL or local file
+            dr.deploy("https://raw.githubusercontent.com/.../model.bim", dataset_name="My 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}"
+            # If using workspace/model format, use the model name
+            if "/" in bim_url and not bim_url.startswith(('http://', 'https://')):
+                parts = bim_url.split("/")
+                if len(parts) == 2:
+                    dataset_name = parts[1]  # Use the model name
+                else:
+                    dataset_name = f"{self.lakehouse_name}_{self.schema}"
+            else:
+                dataset_name = f"{self.lakehouse_name}_{self.schema}"
         
         # Call the deployment function (DirectLake only)
         return deploy_semantic_model(
@@ -731,7 +746,7 @@ class Duckrun:
             lakehouse_name_or_id=self.lakehouse_name,
             schema_name=self.schema,
             dataset_name=dataset_name,
-            bim_url=bim_url,
+            bim_url_or_path=bim_url,
             wait_seconds=wait_seconds
         )
 
@@ -864,6 +879,145 @@ class WorkspaceConnection:
             print(f"❌ Error creating lakehouse '{lakehouse_name}': {e}")
             return False
     
+    def download_bim(self, semantic_model_name: str, output_path: Optional[str] = None) -> Optional[str]:
+        """
+        Download a semantic model as a BIM (Business Intelligence Model) file.
+        
+        Args:
+            semantic_model_name: Name of the semantic model to download
+            output_path: Optional path to save the BIM file. If not provided, returns the BIM content as JSON string
+            
+        Returns:
+            BIM content as JSON string if output_path is None, or the file path if saved successfully
+            
+        Example:
+            con = duckrun.connect("My Workspace")
+            # Get BIM content as string
+            bim_content = con.download_bim("Sales Model")
+            # Or save to file
+            con.download_bim("Sales Model", "sales_model.bim")
+        """
+        try:
+            # Get authentication token
+            from .auth import get_fabric_api_token
+            token = get_fabric_api_token()
+            if not token:
+                print("❌ Failed to authenticate for downloading semantic model")
+                return None
+            
+            # Resolve workspace name to ID
+            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 None
+            
+            # Get semantic model ID
+            print(f"🔍 Looking for semantic model '{semantic_model_name}'...")
+            url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/semanticModels"
+            headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+            
+            response = requests.get(url, headers=headers)
+            response.raise_for_status()
+            
+            models = response.json().get("value", [])
+            model = next((m for m in models if m.get("displayName") == semantic_model_name), None)
+            
+            if not model:
+                print(f"❌ Semantic model '{semantic_model_name}' not found in workspace '{self.workspace_name}'")
+                return None
+            
+            model_id = model.get("id")
+            print(f"✓ Found semantic model: {semantic_model_name} (ID: {model_id})")
+            
+            # Get the model definition using the generic items API
+            print("📥 Downloading BIM definition...")
+            definition_url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/items/{model_id}/getDefinition"
+            
+            # POST request to get definition with TMSL format (which includes model.bim)
+            # Note: format parameter should be in query string, not body
+            response = requests.post(f"{definition_url}?format=TMSL", headers=headers)
+            response.raise_for_status()
+            
+            # Handle long-running operation if needed
+            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
+                    result_url = f"https://api.fabric.microsoft.com/v1/operations/{operation_id}/result"
+                    result_response = requests.get(result_url, headers=headers)
+                    
+                    # Check operation status
+                    status_url = f"https://api.fabric.microsoft.com/v1/operations/{operation_id}"
+                    status_response = requests.get(status_url, headers=headers)
+                    status = status_response.json().get('status')
+                    
+                    if status == 'Succeeded':
+                        result_data = result_response.json()
+                        break
+                    elif status == 'Failed':
+                        error = status_response.json().get('error', {})
+                        print(f"❌ Operation failed: {error.get('message')}")
+                        return None
+                    elif attempt == max_attempts - 1:
+                        print("❌ Operation timed out")
+                        return None
+            else:
+                result_data = response.json()
+            
+            # Extract BIM content from definition
+            definition = result_data.get('definition', {})
+            parts = definition.get('parts', [])
+            
+            # Debug: show what parts we have
+            if not parts:
+                print("❌ No definition parts found in response")
+                print(f"   Result data keys: {list(result_data.keys())}")
+                print(f"   Definition keys: {list(definition.keys()) if definition else 'None'}")
+                return None
+            
+            print(f"   Found {len(parts)} definition parts:")
+            for part in parts:
+                print(f"     - {part.get('path', 'unknown')}")
+            
+            bim_part = next((p for p in parts if p.get('path', '').endswith('.bim')), None)
+            if not bim_part:
+                print("❌ No BIM file found in semantic model definition")
+                print(f"   Looking for files ending with '.bim', found: {[p.get('path') for p in parts]}")
+                return None
+            
+            # Decode the BIM content (it's base64 encoded)
+            import base64
+            bim_payload = bim_part.get('payload', '')
+            bim_content = base64.b64decode(bim_payload).decode('utf-8')
+            bim_json = json.loads(bim_content)
+            
+            # Format as pretty JSON
+            bim_formatted = json.dumps(bim_json, indent=2)
+            
+            print(f"✓ BIM file downloaded successfully")
+            print(f"  - Tables: {len(bim_json.get('model', {}).get('tables', []))}")
+            print(f"  - Relationships: {len(bim_json.get('model', {}).get('relationships', []))}")
+            
+            # Save to file or return content
+            if output_path:
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(bim_formatted)
+                print(f"✓ Saved to: {output_path}")
+                return output_path
+            else:
+                return bim_formatted
+                
+        except Exception as e:
+            print(f"❌ Error downloading semantic model: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+    
     def _get_workspace_id_by_name(self, token: str, workspace_name: str) -> Optional[str]:
         """Helper method to get workspace ID from name"""
         try:

duckrun/semantic_model.py

@@ -186,13 +186,107 @@ def refresh_dataset(dataset_name, workspace_id, client, dataset_id=None):
         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")
+def download_bim_from_github(url_or_path):
+    """
+    Load BIM file from URL, local file path, or workspace/model format.
+    
+    Args:
+        url_or_path: Can be:
+            - Local file path: "model.bim"
+            - URL: "https://..."
+            - Workspace/Model: "workspace_name/semantic_model_name"
+        
+    Returns:
+        BIM content as dictionary
+    """
+    import os
+    import tempfile
+    
+    # Check if it's a local file path
+    if os.path.exists(url_or_path):
+        print(f"Loading BIM file from local path...")
+        with open(url_or_path, 'r', encoding='utf-8') as f:
+            bim_content = json.load(f)
+        print(f"✓ BIM file loaded from: {url_or_path}")
+    # Check if it's a URL
+    elif url_or_path.startswith(('http://', 'https://')):
+        print(f"Downloading BIM file from URL...")
+        response = requests.get(url_or_path)
+        response.raise_for_status()
+        bim_content = response.json()
+        print(f"✓ BIM file downloaded from URL")
+    # Check if it's workspace/model format
+    elif "/" in url_or_path and not os.path.exists(url_or_path):
+        print(f"Downloading BIM from workspace/model...")
+        parts = url_or_path.split("/")
+        if len(parts) != 2:
+            raise ValueError(f"Invalid workspace/model format: '{url_or_path}'. Expected: 'workspace_name/model_name'")
+        
+        ws_name, model_name = parts
+        
+        # Download BIM from the semantic model
+        client = FabricRestClient()
+        ws_id = get_workspace_id(ws_name, client)
+        
+        # Get semantic model ID
+        response = client.get(f"/v1/workspaces/{ws_id}/semanticModels")
+        models = response.json().get('value', [])
+        model = next((m for m in models if m.get('displayName') == model_name), None)
+        
+        if not model:
+            raise ValueError(f"Semantic model '{model_name}' not found in workspace '{ws_name}'")
+        
+        model_id = model.get('id')
+        
+        # Get definition using Items API with TMSL format
+        definition_url = f"https://api.fabric.microsoft.com/v1/workspaces/{ws_id}/items/{model_id}/getDefinition"
+        headers = client._get_headers()
+        response = requests.post(f"{definition_url}?format=TMSL", headers=headers)
+        response.raise_for_status()
+        
+        # Handle long-running operation
+        if response.status_code == 202:
+            operation_id = response.headers.get('x-ms-operation-id')
+            max_attempts = 30
+            
+            for attempt in range(max_attempts):
+                time.sleep(2)
+                
+                status_url = f"https://api.fabric.microsoft.com/v1/operations/{operation_id}"
+                status_response = requests.get(status_url, headers=headers)
+                status = status_response.json().get('status')
+                
+                if status == 'Succeeded':
+                    result_url = f"https://api.fabric.microsoft.com/v1/operations/{operation_id}/result"
+                    result_response = requests.get(result_url, headers=headers)
+                    result_data = result_response.json()
+                    break
+                elif status == 'Failed':
+                    error = status_response.json().get('error', {})
+                    raise Exception(f"Download operation failed: {error.get('message')}")
+                elif attempt == max_attempts - 1:
+                    raise Exception("Download operation timed out")
+        else:
+            result_data = response.json()
+        
+        # Extract BIM content
+        definition = result_data.get('definition', {})
+        parts = definition.get('parts', [])
+        
+        bim_part = next((p for p in parts if p.get('path', '').endswith('.bim')), None)
+        if not bim_part:
+            raise Exception("No BIM file found in semantic model definition")
+        
+        # Decode BIM
+        import base64
+        bim_payload = bim_part.get('payload', '')
+        bim_content_str = base64.b64decode(bim_payload).decode('utf-8')
+        bim_content = json.loads(bim_content_str)
+        
+        print(f"✓ BIM downloaded from {ws_name}/{model_name}")
+    else:
+        raise ValueError(f"Invalid BIM source: '{url_or_path}'. Must be a valid file path, URL, or 'workspace/model' format.")
+    
     print(f"  - Tables: {len(bim_content.get('model', {}).get('tables', []))}")
     print(f"  - Relationships: {len(bim_content.get('model', {}).get('relationships', []))}")
     return bim_content
@@ -299,23 +393,27 @@ def create_dataset_from_bim(dataset_name, bim_content, workspace_id, client):
         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)
+                
+                # Now get the result (only after status is Succeeded)
+                try:
+                    result_response = client.get(f"/v1/operations/{operation_id}/result")
+                    result_data = result_response.json()
+                    dataset_id = result_data.get('id')
+                    if dataset_id:
+                        return dataset_id
+                except:
+                    # If result endpoint fails, fallback to searching by name
+                    pass
+                
+                # 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')}")
@@ -333,7 +431,7 @@ def create_dataset_from_bim(dataset_name, bim_content, workspace_id, client):
 
 
 def deploy_semantic_model(workspace_name_or_id, lakehouse_name_or_id, schema_name, dataset_name, 
-                         bim_url, wait_seconds=5):
+                         bim_url_or_path, wait_seconds=5):
     """
     Deploy a semantic model using DirectLake mode.
     
@@ -342,15 +440,20 @@ def deploy_semantic_model(workspace_name_or_id, lakehouse_name_or_id, schema_nam
         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
+        bim_url_or_path: URL to the BIM file or local file path (e.g., 'model.bim' or 'https://...')
         wait_seconds: Seconds to wait before refresh (default: 5)
     
     Returns:
         1 for success, 0 for failure
     
     Examples:
+        # Using a URL
         dr = Duckrun.connect("My Workspace/My Lakehouse.lakehouse/dbo")
         dr.deploy("https://raw.githubusercontent.com/.../model.bim")
+        
+        # Using a local file
+        dr.deploy("./my_model.bim")
+        dr.deploy("C:/path/to/model.bim")
     """
     print("=" * 70)
     print("Semantic Model Deployment (DirectLake)")
@@ -389,8 +492,8 @@ def deploy_semantic_model(workspace_name_or_id, lakehouse_name_or_id, schema_nam
         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)
+        print("\n[Step 4/6] Loading and configuring BIM file...")
+        bim_content = download_bim_from_github(bim_url_or_path)
         
         modified_bim = update_bim_for_directlake(bim_content, workspace_id, lakehouse_id, schema_name)
         modified_bim['name'] = dataset_name
@@ -432,3 +535,187 @@ def deploy_semantic_model(workspace_name_or_id, lakehouse_name_or_id, schema_nam
         print(f"  - Check tables are in Delta format")
         print("=" * 70)
         return 0
+
+
+def copy_model(ws_source, model_name, destination, new_model_name=None, wait_seconds=5):
+    """
+    Copy a semantic model from one workspace to another.
+    
+    This is a convenience function that downloads a BIM file from a source workspace
+    and deploys it to a destination lakehouse in one operation.
+    
+    Args:
+        ws_source: Source workspace name or GUID
+        model_name: Name of the semantic model to copy
+        destination: Destination in format "workspace/lakehouse.lakehouse/schema"
+        new_model_name: Name for the new semantic model (default: same as source)
+        wait_seconds: Seconds to wait before refresh (default: 5)
+    
+    Returns:
+        1 for success, 0 for failure
+    
+    Examples:
+        # Copy to same workspace, different lakehouse
+        copy_model("My Workspace", "Sales Model", "My Workspace/Target Lakehouse.lakehouse/dbo")
+        
+        # Copy to different workspace with new name
+        copy_model("Source WS", "Production Model", "Target WS/Data Lake.lakehouse/analytics", 
+                   new_model_name="Production Model - Copy")
+        
+        # Using the connect pattern
+        import duckrun
+        duckrun.semantic_model.copy_model("Source", "Model", "Target/LH.lakehouse/dbo")
+    """
+    import tempfile
+    import os
+    
+    print("=" * 70)
+    print("Semantic Model Copy Operation")
+    print("=" * 70)
+    
+    try:
+        # Parse destination
+        parts = destination.split("/")
+        if len(parts) != 3:
+            raise ValueError(
+                f"Invalid destination format: '{destination}'. "
+                "Expected format: 'workspace/lakehouse.lakehouse/schema'"
+            )
+        
+        ws_dest, lakehouse, schema = parts
+        
+        # Remove .lakehouse suffix if present
+        if lakehouse.endswith(".lakehouse"):
+            lakehouse = lakehouse[:-10]
+        
+        # Use source model name if new name not provided
+        if not new_model_name:
+            new_model_name = model_name
+        
+        print(f"\nSource:")
+        print(f"  Workspace: {ws_source}")
+        print(f"  Model: {model_name}")
+        print(f"\nDestination:")
+        print(f"  Workspace: {ws_dest}")
+        print(f"  Lakehouse: {lakehouse}")
+        print(f"  Schema: {schema}")
+        print(f"  New Model Name: {new_model_name}")
+        
+        # Step 1: Download BIM from source
+        print("\n" + "-" * 70)
+        print("[Step 1/2] Downloading BIM from source workspace...")
+        print("-" * 70)
+        
+        client = FabricRestClient()
+        ws_source_id = get_workspace_id(ws_source, client)
+        
+        # Use temporary file for BIM content
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.bim', delete=False, encoding='utf-8') as tmp_file:
+            temp_bim_path = tmp_file.name
+            
+            # Get semantic model ID
+            response = client.get(f"/v1/workspaces/{ws_source_id}/semanticModels")
+            models = response.json().get('value', [])
+            model = next((m for m in models if m.get('displayName') == model_name), None)
+            
+            if not model:
+                raise ValueError(f"Semantic model '{model_name}' not found in workspace '{ws_source}'")
+            
+            model_id = model.get('id')
+            print(f"✓ Found source model: {model_name} (ID: {model_id})")
+            
+            # Get definition using Items API with TMSL format
+            print("  Downloading BIM definition...")
+            definition_url = f"https://api.fabric.microsoft.com/v1/workspaces/{ws_source_id}/items/{model_id}/getDefinition"
+            headers = client._get_headers()
+            response = requests.post(f"{definition_url}?format=TMSL", headers=headers)
+            response.raise_for_status()
+            
+            # Handle long-running operation
+            if response.status_code == 202:
+                operation_id = response.headers.get('x-ms-operation-id')
+                max_attempts = 30
+                
+                for attempt in range(max_attempts):
+                    time.sleep(2)
+                    
+                    status_url = f"https://api.fabric.microsoft.com/v1/operations/{operation_id}"
+                    status_response = requests.get(status_url, headers=headers)
+                    status = status_response.json().get('status')
+                    
+                    if status == 'Succeeded':
+                        result_url = f"https://api.fabric.microsoft.com/v1/operations/{operation_id}/result"
+                        result_response = requests.get(result_url, headers=headers)
+                        result_data = result_response.json()
+                        break
+                    elif status == 'Failed':
+                        error = status_response.json().get('error', {})
+                        raise Exception(f"Download operation failed: {error.get('message')}")
+                    elif attempt == max_attempts - 1:
+                        raise Exception("Download operation timed out")
+            else:
+                result_data = response.json()
+            
+            # Extract BIM content
+            definition = result_data.get('definition', {})
+            parts = definition.get('parts', [])
+            
+            bim_part = next((p for p in parts if p.get('path', '').endswith('.bim')), None)
+            if not bim_part:
+                raise Exception("No BIM file found in semantic model definition")
+            
+            # Decode and save BIM
+            import base64
+            bim_payload = bim_part.get('payload', '')
+            bim_content = base64.b64decode(bim_payload).decode('utf-8')
+            bim_json = json.loads(bim_content)
+            
+            # Write to temp file
+            json.dump(bim_json, tmp_file, indent=2)
+            
+            print(f"✓ BIM downloaded successfully")
+            print(f"  - Tables: {len(bim_json.get('model', {}).get('tables', []))}")
+            print(f"  - Relationships: {len(bim_json.get('model', {}).get('relationships', []))}")
+        
+        # Step 2: Deploy to destination
+        print("\n" + "-" * 70)
+        print("[Step 2/2] Deploying to destination workspace...")
+        print("-" * 70)
+        
+        result = deploy_semantic_model(
+            workspace_name_or_id=ws_dest,
+            lakehouse_name_or_id=lakehouse,
+            schema_name=schema,
+            dataset_name=new_model_name,
+            bim_url_or_path=temp_bim_path,
+            wait_seconds=wait_seconds
+        )
+        
+        # Clean up temp file
+        try:
+            os.unlink(temp_bim_path)
+        except:
+            pass
+        
+        if result == 1:
+            print("\n" + "=" * 70)
+            print("🎉 Copy Operation Completed!")
+            print("=" * 70)
+            print(f"Source: {ws_source}/{model_name}")
+            print(f"Destination: {ws_dest}/{lakehouse}/{schema}/{new_model_name}")
+            print("=" * 70)
+        
+        return result
+        
+    except Exception as e:
+        print("\n" + "=" * 70)
+        print("❌ Copy Operation Failed")
+        print("=" * 70)
+        print(f"Error: {str(e)}")
+        print("\n💡 Troubleshooting:")
+        print(f"  - Verify source workspace '{ws_source}' and model '{model_name}' exist")
+        print(f"  - Verify destination workspace and lakehouse exist")
+        print(f"  - Ensure you have permissions for both workspaces")
+        print("=" * 70)
+        return 0
+

duckrun/stats.py

@@ -4,6 +4,7 @@ Delta Lake table statistics functionality for duckrun
 import duckdb
 from deltalake import DeltaTable
 from datetime import datetime
+import pyarrow as pa
 
 
 def _table_exists(duckrun_instance, schema_name: str, table_name: str) -> bool:
@@ -149,17 +150,23 @@ def get_stats(duckrun_instance, source: str):
             dt = DeltaTable(table_path)
             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)
+            # Convert RecordBatch to dict - works with both PyArrow (deltalake 0.18.2) and arro3 (newer versions)
+            # Strategy: Use duck typing - try direct conversion first, then manual extraction
+            # This works because both PyArrow and arro3 RecordBatches have schema and column() methods
+            
             try:
+                # Old deltalake (0.18.2): PyArrow RecordBatch has to_pydict() directly
                 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()}
+                # New deltalake with arro3: Use schema and column() methods
+                # This is the universal approach that works with both PyArrow and arro3
+                if hasattr(add_actions, 'schema') and hasattr(add_actions, 'column'):
+                    # Extract columns manually and create PyArrow table
+                    arrow_table = pa.table({name: add_actions.column(name) for name in add_actions.schema.names})
+                    xx = arrow_table.to_pydict()
                 else:
+                    # Fallback: empty dict (shouldn't happen)
+                    print(f"Warning: Could not convert RecordBatch for table '{tbl}': Unexpected type {type(add_actions)}")
                     xx = {}
             
             # Check if VORDER exists

{duckrun-0.2.9.dev5.dist-info → duckrun-0.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckrun
-Version: 0.2.9.dev5
+Version: 0.2.10
 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.10.dist-info/RECORD

@@ -0,0 +1,14 @@
+duckrun/__init__.py,sha256=cTj6KQ6hKmgu1z7k9nhDcO5lct049luxjx1V0QnymCo,235
+duckrun/auth.py,sha256=qPaLQ7InlV9leA9r6E6VEeYavFFoBi0zSN8m_l1aoQs,9545
+duckrun/core.py,sha256=g9WtvhROxFSo2Idb979fY5HhxbMm_x-tajc_zWMtqCU,46853
+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=obzlN2-dbEW3JmDop-vrZGGGLi9u3ThhTbgtDjou7uY,29509
+duckrun/stats.py,sha256=oKIjZ7u5cFVT63FuOl5UqoDsOG3098woSCn-uI6i_sQ,11084
+duckrun/writer.py,sha256=svUuPCYOhrz299NgnpTKhARKjfej0PxnoND2iPDSypk,8098
+duckrun-0.2.10.dist-info/licenses/LICENSE,sha256=-DeQQwdbCbkB4507ZF3QbocysB-EIjDtaLexvqRkGZc,1083
+duckrun-0.2.10.dist-info/METADATA,sha256=CwDyjJqyfBoISxZ1bfdojVVsP0HcrLylgqCTpMsC6e8,20624
+duckrun-0.2.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+duckrun-0.2.10.dist-info/top_level.txt,sha256=BknMEwebbUHrVAp3SC92ps8MPhK7XSYsaogTvi_DmEU,8
+duckrun-0.2.10.dist-info/RECORD,,

duckrun-0.2.9.dev5.dist-info/RECORD

@@ -1,14 +0,0 @@
-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.dev5.dist-info/licenses/LICENSE,sha256=-DeQQwdbCbkB4507ZF3QbocysB-EIjDtaLexvqRkGZc,1083
-duckrun-0.2.9.dev5.dist-info/METADATA,sha256=r0oG0-EI5oE-UgfRWJskXHHc4u7uNhFrdPFsTrCtGwc,19277
-duckrun-0.2.9.dev5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-duckrun-0.2.9.dev5.dist-info/top_level.txt,sha256=BknMEwebbUHrVAp3SC92ps8MPhK7XSYsaogTvi_DmEU,8
-duckrun-0.2.9.dev5.dist-info/RECORD,,