duckrun 0.2.13__py3-none-any.whl → 0.2.19.dev1__py3-none-any.whl

duckrun/notebook.py

@@ -0,0 +1,324 @@
+"""
+Notebook operations functionality for duckrun - Import notebooks from web using Fabric REST API
+"""
+import requests
+import base64
+from typing import Optional
+
+
+def import_notebook_from_web(
+    url: str,
+    notebook_name: Optional[str] = None,
+    overwrite: bool = False,
+    workspace_name: Optional[str] = None
+) -> dict:
+    """
+    Import a Jupyter notebook from a web URL into Microsoft Fabric workspace using REST API only.
+    Uses duckrun.connect context by default or explicit workspace name.
+    
+    Args:
+        url: URL to the notebook file (e.g., GitHub raw URL). Required.
+        notebook_name: Name for the imported notebook in Fabric. Optional - will use filename from URL if not provided.
+        overwrite: Whether to overwrite if notebook already exists (default: False)
+        workspace_name: Target workspace name. Optional - will use current workspace from duckrun context if available.
+        
+    Returns:
+        Dictionary with import result:
+        {
+            "success": bool,
+            "message": str,
+            "notebook": dict (if successful),
+            "overwritten": bool
+        }
+        
+    Examples:
+        # Basic usage with duckrun context
+        import duckrun
+        dr = duckrun.connect("MyWorkspace/MyLakehouse.lakehouse")
+        from duckrun.notebook import import_notebook_from_web
+        
+        result = import_notebook_from_web(
+            url="https://raw.githubusercontent.com/user/repo/main/notebook.ipynb",
+            notebook_name="MyNotebook"
+        )
+        
+        # With explicit workspace
+        result = import_notebook_from_web(
+            url="https://raw.githubusercontent.com/user/repo/main/notebook.ipynb",
+            notebook_name="MyNotebook",
+            workspace_name="Analytics Workspace",
+            overwrite=True
+        )
+        
+        # Minimal usage - derives name from URL
+        result = import_notebook_from_web(
+            url="https://raw.githubusercontent.com/user/repo/main/RunPerfScenario.ipynb"
+        )
+    """
+    try:
+        # Get authentication token
+        from duckrun.auth import get_fabric_api_token
+        token = get_fabric_api_token()
+        if not token:
+            return {
+                "success": False,
+                "message": "Failed to get authentication token",
+                "notebook": None,
+                "overwritten": False
+            }
+        
+        base_url = "https://api.fabric.microsoft.com/v1"
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json"
+        }
+        
+        # Determine workspace ID
+        workspace_id = None
+        
+        # Try to get from duckrun context if not provided
+        if not workspace_name:
+            try:
+                # Try to get from notebook context first
+                import notebookutils  # type: ignore
+                workspace_id = notebookutils.runtime.context.get("workspaceId")
+                print("📓 Using current workspace from Fabric notebook context")
+            except (ImportError, Exception):
+                # Not in notebook, try to get from environment/last connection
+                pass
+        
+        # If still no workspace_id, resolve from workspace_name
+        if not workspace_id:
+            if not workspace_name:
+                return {
+                    "success": False,
+                    "message": "workspace_name must be provided when not in Fabric notebook context",
+                    "notebook": None,
+                    "overwritten": False
+                }
+            
+            # Get workspace ID by name
+            print(f"🔍 Resolving workspace: {workspace_name}")
+            ws_url = f"{base_url}/workspaces"
+            response = requests.get(ws_url, headers=headers)
+            response.raise_for_status()
+            
+            workspaces = response.json().get("value", [])
+            workspace = next((ws for ws in workspaces if ws.get("displayName") == workspace_name), None)
+            
+            if not workspace:
+                return {
+                    "success": False,
+                    "message": f"Workspace '{workspace_name}' not found",
+                    "notebook": None,
+                    "overwritten": False
+                }
+            
+            workspace_id = workspace.get("id")
+            print(f"✓ Found workspace: {workspace_name}")
+        
+        # Derive notebook name from URL if not provided
+        if not notebook_name:
+            # Extract filename from URL
+            notebook_name = url.split("/")[-1]
+            if notebook_name.endswith(".ipynb"):
+                notebook_name = notebook_name[:-6]  # Remove .ipynb extension
+            print(f"📝 Using notebook name from URL: {notebook_name}")
+        
+        # Check if notebook already exists
+        notebooks_url = f"{base_url}/workspaces/{workspace_id}/notebooks"
+        response = requests.get(notebooks_url, headers=headers)
+        response.raise_for_status()
+        
+        notebooks = response.json().get("value", [])
+        existing_notebook = next((nb for nb in notebooks if nb.get("displayName") == notebook_name), None)
+        
+        if existing_notebook and not overwrite:
+            return {
+                "success": True,
+                "message": f"Notebook '{notebook_name}' already exists (use overwrite=True to replace)",
+                "notebook": existing_notebook,
+                "overwritten": False
+            }
+        
+        # Download notebook content from URL
+        print(f"⬇️ Downloading notebook from: {url}")
+        response = requests.get(url)
+        response.raise_for_status()
+        notebook_content = response.text
+        print(f"✓ Notebook downloaded successfully")
+        
+        # Convert notebook content to base64
+        notebook_base64 = base64.b64encode(notebook_content.encode('utf-8')).decode('utf-8')
+        
+        # Prepare the payload for creating/updating the notebook
+        if existing_notebook and overwrite:
+            # Update existing notebook
+            notebook_id = existing_notebook.get("id")
+            print(f"🔄 Updating existing notebook: {notebook_name}")
+            
+            update_url = f"{base_url}/workspaces/{workspace_id}/notebooks/{notebook_id}/updateDefinition"
+            payload = {
+                "definition": {
+                    "format": "ipynb",
+                    "parts": [
+                        {
+                            "path": "notebook-content.py",
+                            "payload": notebook_base64,
+                            "payloadType": "InlineBase64"
+                        }
+                    ]
+                }
+            }
+            
+            response = requests.post(update_url, headers=headers, json=payload)
+            response.raise_for_status()
+            
+            # Handle long-running operation
+            if response.status_code == 202:
+                operation_id = response.headers.get('x-ms-operation-id')
+                if operation_id:
+                    _wait_for_operation(operation_id, headers)
+            
+            return {
+                "success": True,
+                "message": f"Notebook '{notebook_name}' updated successfully",
+                "notebook": existing_notebook,
+                "overwritten": True
+            }
+        else:
+            # Create new notebook
+            print(f"➕ Creating new notebook: {notebook_name}")
+            
+            payload = {
+                "displayName": notebook_name,
+                "definition": {
+                    "format": "ipynb",
+                    "parts": [
+                        {
+                            "path": "notebook-content.py",
+                            "payload": notebook_base64,
+                            "payloadType": "InlineBase64"
+                        }
+                    ]
+                }
+            }
+            
+            response = requests.post(notebooks_url, headers=headers, json=payload)
+            response.raise_for_status()
+            
+            # Handle long-running operation
+            if response.status_code == 202:
+                operation_id = response.headers.get('x-ms-operation-id')
+                if operation_id:
+                    _wait_for_operation(operation_id, headers)
+            
+            created_notebook = response.json()
+            
+            return {
+                "success": True,
+                "message": f"Notebook '{notebook_name}' created successfully",
+                "notebook": created_notebook,
+                "overwritten": False
+            }
+            
+    except requests.exceptions.RequestException as e:
+        return {
+            "success": False,
+            "message": f"HTTP Error: {str(e)}",
+            "notebook": None,
+            "overwritten": False
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "message": f"Error: {str(e)}",
+            "notebook": None,
+            "overwritten": False
+        }
+
+
+def _wait_for_operation(operation_id: str, headers: dict, max_attempts: int = 30) -> bool:
+    """
+    Wait for a long-running Fabric API operation to complete.
+    
+    Args:
+        operation_id: The operation ID to monitor
+        headers: Request headers with authentication
+        max_attempts: Maximum number of polling attempts (default: 30)
+        
+    Returns:
+        True if operation succeeded, False otherwise
+    """
+    import time
+    
+    status_url = f"https://api.fabric.microsoft.com/v1/operations/{operation_id}"
+    
+    for attempt in range(max_attempts):
+        time.sleep(2)
+        
+        try:
+            response = requests.get(status_url, headers=headers)
+            response.raise_for_status()
+            
+            status_data = response.json()
+            status = status_data.get('status')
+            
+            if status == 'Succeeded':
+                print(f"✓ Operation completed successfully")
+                return True
+            elif status == 'Failed':
+                error = status_data.get('error', {})
+                print(f"❌ Operation failed: {error.get('message', 'Unknown error')}")
+                return False
+            else:
+                print(f"⏳ Operation in progress... ({status})")
+                
+        except Exception as e:
+            print(f"⚠️ Error checking operation status: {e}")
+            return False
+    
+    print(f"⚠️ Operation timed out after {max_attempts} attempts")
+    return False
+
+
+# Convenience wrapper for the try-except pattern mentioned in the request
+def import_notebook(
+    url: str,
+    notebook_name: Optional[str] = None,
+    overwrite: bool = False,
+    workspace_name: Optional[str] = None
+) -> None:
+    """
+    Convenience wrapper that prints results and handles errors.
+    
+    Args:
+        url: URL to the notebook file
+        notebook_name: Name for the imported notebook
+        overwrite: Whether to overwrite if exists
+        workspace_name: Target workspace name
+        
+    Examples:
+        from duckrun.notebook import import_notebook
+        
+        import_notebook(
+            url="https://raw.githubusercontent.com/djouallah/fabric_demo/refs/heads/main/Benchmark/RunPerfScenario.ipynb",
+            notebook_name="RunPerfScenario",
+            overwrite=False
+        )
+    """
+    try:
+        result = import_notebook_from_web(
+            url=url,
+            notebook_name=notebook_name,
+            overwrite=overwrite,
+            workspace_name=workspace_name
+        )
+        
+        if result["success"]:
+            print(f"✅ {result['message']}")
+        else:
+            print(f"❌ {result['message']}")
+            
+    except Exception as e:
+        print(f"Error: {e}")

duckrun/runner.py

@@ -7,45 +7,7 @@ import importlib.util
 from typing import List, Tuple, Dict, Optional, Callable, Any
 from string import Template
 from deltalake import DeltaTable, write_deltalake
-# Row Group configuration for optimal Delta Lake performance
-RG = 8_000_000
-
-
-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 (if supported)
-    """
-    args = {
-        'table_or_uri': path,
-        'data': df,
-        'mode': mode
-    }
-    
-    # Add partition_by if specified
-    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)
-        args['schema_mode'] = 'merge'
-        args['engine'] = 'rust'
-    else:
-        # 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
+from .writer import _build_write_deltalake_args
 
 
 def run(duckrun_instance, pipeline: List[Tuple]) -> bool:
@@ -130,9 +92,12 @@ def _run_python(duckrun_instance, name: str, args: tuple) -> Any:
     
     # Get original and resolved names
     original_workspace = duckrun_instance.workspace
-    original_lakehouse = duckrun_instance.lakehouse_name
+    original_lakehouse = duckrun_instance.lakehouse_display_name  # Base name without suffix (e.g., "data")
     resolved_workspace = duckrun_instance.workspace_id
-    resolved_lakehouse = duckrun_instance.lakehouse_id
+    
+    # Always pass base lakehouse name (without .Lakehouse suffix) to user functions
+    # User functions expect just the name like "data", not "data.Lakehouse"
+    resolved_lakehouse = duckrun_instance.lakehouse_display_name
     
     # Substitute workspace/lakehouse names in args if they differ
     # This prevents URL encoding issues when names contain spaces
@@ -149,7 +114,7 @@ def _run_python(duckrun_instance, name: str, args: tuple) -> Any:
             else:
                 substituted_args.append(arg)
         args = tuple(substituted_args)
-        print(f"📝 Auto-substituted workspace/lakehouse names in args for URL compatibility")
+        print(f"📝 Auto-substituted workspace/lakehouse names in args")
     
     print(f"Running Python: {name}{args}")
     result = func(*args)
@@ -282,12 +247,17 @@ def _read_sql_file(duckrun_instance, table_name: str, params: Optional[Dict] = N
             # If GUID, use just the GUID
             content = content.replace('${lh}.Lakehouse', duckrun_instance.lakehouse_name)
         else:
-            # If not GUID, use legacy format
-            content = content.replace('${lh}.Lakehouse', f'{duckrun_instance.lakehouse_name}.Lakehouse')
+            # If not GUID, check if lakehouse_name already has .ItemType suffix
+            if duckrun_instance.lakehouse_name.endswith(('.Lakehouse', '.Warehouse', '.Database', '.SnowflakeDatabase')):
+                # Already has suffix - use as is
+                content = content.replace('${lh}.Lakehouse', duckrun_instance.lakehouse_name)
+            else:
+                # No suffix - add .Lakehouse for legacy format
+                content = content.replace('${lh}.Lakehouse', f'{duckrun_instance.lakehouse_name}.Lakehouse')
 
     full_params = {
         'ws': duckrun_instance.workspace,
-        'lh': duckrun_instance.lakehouse_name,
+        'lh': duckrun_instance.lakehouse_display_name,  # Use display name (without suffix) for backward compat
         'schema': duckrun_instance.schema,
         'storage_account': duckrun_instance.storage_account,
         'tables_url': duckrun_instance.table_base_url,

duckrun/semantic_model.py

@@ -129,29 +129,136 @@ def check_dataset_exists(dataset_name, workspace_id, client):
         return False
 
 
-def refresh_dataset(dataset_name, workspace_id, client, dataset_id=None):
-    """Refresh a dataset and monitor progress using Power BI API"""
+def refresh_dataset(dataset_name, workspace_id, client, dataset_id=None, refresh="full"):
+    """Refresh a dataset and monitor progress using Power BI API
+    
+    For DirectLake models, performs refresh based on refresh parameter:
+    - refresh="full": Two-step refresh (clearValues + full reframe)
+    - refresh="ignore": Skip refresh entirely
+    
+    If a refresh is already in progress, waits for it to complete before starting a new one.
+    """
+    
+    # Skip refresh entirely if refresh is "ignore"
+    if refresh == "ignore":
+        print("   Ignoring refresh - skipping refresh")
+        return
     
     # 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",
+    # 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()
+    
+    # Check for in-progress refreshes
+    print("   Checking for in-progress refreshes...")
+    try:
+        status_response = requests.get(f"{powerbi_url}?$top=1", headers=headers)
+        if status_response.status_code == 200:
+            refreshes = status_response.json().get('value', [])
+            if refreshes:
+                latest_refresh = refreshes[0]
+                status = latest_refresh.get('status')
+                if status in ['InProgress', 'Unknown']:
+                    refresh_id = latest_refresh.get('requestId')
+                    print(f"   ⚠️  Found in-progress refresh (ID: {refresh_id})")
+                    print(f"   Waiting for current refresh to complete...")
+                    
+                    # Wait for the in-progress refresh to complete
+                    max_wait_attempts = 60
+                    for attempt in range(max_wait_attempts):
+                        time.sleep(5)
+                        check_response = requests.get(f"{powerbi_url}/{refresh_id}", headers=headers)
+                        if check_response.status_code == 200:
+                            current_status = check_response.json().get('status')
+                            
+                            if current_status == 'Completed':
+                                print(f"   ✓ Previous refresh completed")
+                                break
+                            elif current_status == 'Failed':
+                                print(f"   ⚠️  Previous refresh failed, continuing with new refresh")
+                                break
+                            elif current_status == 'Cancelled':
+                                print(f"   ⚠️  Previous refresh was cancelled, continuing with new refresh")
+                                break
+                            
+                            if attempt % 6 == 0:
+                                print(f"   Still waiting... (status: {current_status})")
+                    else:
+                        print(f"   ⚠️  Timeout waiting for previous refresh, will attempt new refresh anyway")
+    except Exception as e:
+        print(f"   ⚠️  Could not check refresh status: {e}")
+        print(f"   Continuing with refresh attempt...")
+    
+    # Step 1: clearValues - Purge data from memory
+    print("   Step 1: Clearing values from memory...")
+    clearvalues_payload = {
+        "type": "clearValues",
         "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=clearvalues_payload)
     
-    response = requests.post(powerbi_url, headers=headers, json=payload)
+    if response.status_code in [200, 202]:
+        # For 202, monitor the clearValues operation
+        if response.status_code == 202:
+            location = response.headers.get('Location')
+            if location:
+                clear_refresh_id = location.split('/')[-1]
+                print("   ✓ Clear values initiated, monitoring progress...")
+                
+                max_attempts = 60
+                for attempt in range(max_attempts):
+                    time.sleep(2)
+                    
+                    status_url = f"https://api.powerbi.com/v1.0/myorg/datasets/{dataset_id}/refreshes/{clear_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"   ✓ Clear values completed")
+                        break
+                    elif status == 'Failed':
+                        error = status_response.json().get('serviceExceptionJson', '')
+                        raise Exception(f"Clear values failed: {error}")
+                    elif status == 'Cancelled':
+                        raise Exception("Clear values was cancelled")
+                    
+                    if attempt % 10 == 0 and attempt > 0:
+                        print(f"   Clear values status: {status}...")
+                else:
+                    raise Exception(f"Clear values timed out")
+        else:
+            print("   ✓ Clear values completed")
+    else:
+        # Provide detailed error message
+        try:
+            error_details = response.json()
+            error_message = error_details.get('error', {}).get('message', response.text)
+            raise Exception(f"Clear values failed with status {response.status_code}: {error_message}")
+        except (json.JSONDecodeError, ValueError):
+            response.raise_for_status()
+    
+    # Step 2: full refresh - Reframe data from Delta tables
+    print("   Step 2: Full refresh to reframe data...")
+    full_payload = {
+        "type": "full",
+        "commitMode": "transactional",
+        "maxParallelism": 10,
+        "retryCount": 2,
+        "objects": []
+    }
+    
+    response = requests.post(powerbi_url, headers=headers, json=full_payload)
     
     if response.status_code in [200, 202]:
-        print(f"✓ Refresh initiated")
+        print(f"   ✓ Refresh initiated")
         
         # For 202, get the refresh_id from the Location header
         if response.status_code == 202:
@@ -183,7 +290,13 @@ def refresh_dataset(dataset_name, workspace_id, client, dataset_id=None):
                 
                 raise Exception(f"Refresh timed out")
     else:
-        response.raise_for_status()
+        # Provide detailed error message
+        try:
+            error_details = response.json()
+            error_message = error_details.get('error', {}).get('message', response.text)
+            raise Exception(f"Refresh request failed with status {response.status_code}: {error_message}")
+        except (json.JSONDecodeError, ValueError):
+            response.raise_for_status()
 
 
 def download_bim_from_github(url_or_path):
@@ -431,7 +544,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_or_path, wait_seconds=5):
+                         bim_url_or_path, wait_seconds=5, refresh="full"):
     """
     Deploy a semantic model using DirectLake mode.
     
@@ -442,6 +555,9 @@ def deploy_semantic_model(workspace_name_or_id, lakehouse_name_or_id, schema_nam
         dataset_name: Name for the semantic model
         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)
+        refresh: Refresh strategy (default: "full")
+            - "full": Clear values and process full refresh
+            - "ignore": Skip refresh entirely
     
     Returns:
         1 for success, 0 for failure
@@ -454,6 +570,9 @@ def deploy_semantic_model(workspace_name_or_id, lakehouse_name_or_id, schema_nam
         # Using a local file
         dr.deploy("./my_model.bim")
         dr.deploy("C:/path/to/model.bim")
+        
+        # Deploy without refresh
+        dr.deploy("./my_model.bim", refresh="ignore")
     """
     print("=" * 70)
     print("Semantic Model Deployment (DirectLake)")
@@ -471,14 +590,14 @@ def deploy_semantic_model(workspace_name_or_id, lakehouse_name_or_id, schema_nam
         dataset_exists = check_dataset_exists(dataset_name, workspace_id, client)
         
         if dataset_exists:
-            print(f"\n✓ Dataset exists - refreshing...")
+            print(f"✓ Dataset '{dataset_name}' already exists - skipping deployment")
             
             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[Step 3/3] Refreshing existing semantic model...")
+            refresh_dataset(dataset_name, workspace_id, client, refresh=refresh)
             
             print("\n" + "=" * 70)
             print("🎉 Refresh Completed!")
@@ -510,7 +629,7 @@ def deploy_semantic_model(workspace_name_or_id, lakehouse_name_or_id, schema_nam
         
         # 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)
+        refresh_dataset(dataset_name, workspace_id, client, dataset_id=dataset_id, refresh=refresh)
         
         print("\n" + "=" * 70)
         print("🎉 Deployment Completed!")
@@ -537,7 +656,7 @@ def deploy_semantic_model(workspace_name_or_id, lakehouse_name_or_id, schema_nam
         return 0
 
 
-def copy_model(ws_source, model_name, destination, new_model_name=None, wait_seconds=5):
+def copy_model(ws_source, model_name, destination, new_model_name=None, wait_seconds=5, refresh="full"):
     """
     Copy a semantic model from one workspace to another.
     
@@ -550,6 +669,9 @@ def copy_model(ws_source, model_name, destination, new_model_name=None, wait_sec
         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)
+        refresh: Refresh strategy (default: "full")
+            - "full": Clear values and process full refresh
+            - "ignore": Skip refresh entirely
     
     Returns:
         1 for success, 0 for failure
@@ -562,6 +684,9 @@ def copy_model(ws_source, model_name, destination, new_model_name=None, wait_sec
         copy_model("Source WS", "Production Model", "Target WS/Data Lake.lakehouse/analytics", 
                    new_model_name="Production Model - Copy")
         
+        # Copy without refresh
+        copy_model("Source WS", "Model", "Target WS/LH.lakehouse/dbo", refresh="ignore")
+        
         # Using the connect pattern
         import duckrun
         duckrun.semantic_model.copy_model("Source", "Model", "Target/LH.lakehouse/dbo")
@@ -688,7 +813,8 @@ def copy_model(ws_source, model_name, destination, new_model_name=None, wait_sec
             schema_name=schema,
             dataset_name=new_model_name,
             bim_url_or_path=temp_bim_path,
-            wait_seconds=wait_seconds
+            wait_seconds=wait_seconds,
+            refresh=refresh
         )
         
         # Clean up temp file