duckrun 0.2.9.dev1__tar.gz → 0.2.9.dev3__tar.gz

{duckrun-0.2.9.dev1 → duckrun-0.2.9.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckrun
-Version: 0.2.9.dev1
+Version: 0.2.9.dev3
 Summary: Lakehouse task runner powered by DuckDB for Microsoft Fabric
 Author: mim
 License: MIT

{duckrun-0.2.9.dev1 → duckrun-0.2.9.dev3}/duckrun/__init__.py

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

{duckrun-0.2.9.dev1 → duckrun-0.2.9.dev3}/duckrun/auth.py

@@ -123,6 +123,12 @@ def get_fabric_api_token() -> Optional[str]:
     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
@@ -130,6 +136,7 @@ def get_fabric_api_token() -> Optional[str]:
         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:
@@ -158,6 +165,7 @@ def get_fabric_api_token() -> Optional[str]:
                 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:
@@ -167,6 +175,7 @@ def get_fabric_api_token() -> Optional[str]:
                 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
         

{duckrun-0.2.9.dev1 → duckrun-0.2.9.dev3}/duckrun/core.py

@@ -727,8 +727,8 @@ class Duckrun:
         
         # Call the deployment function (DirectLake only)
         return deploy_semantic_model(
-            workspace_name=self.workspace,
-            lakehouse_name=self.lakehouse_name,
+            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,

{duckrun-0.2.9.dev1 → duckrun-0.2.9.dev3}/duckrun/semantic_model.py

@@ -43,31 +43,66 @@ class FabricRestClient:
         return response
 
 
-def get_workspace_id(workspace_name, client):
-    """Get workspace ID by name"""
+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), None)
+    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}' not found")
+        raise ValueError(f"Workspace '{workspace_name_or_id}' not found")
     
     workspace_id = workspace_match['id']
-    print(f"✓ Found workspace: {workspace_name}")
+    print(f"✓ Found workspace: {workspace_name_or_id}")
     return workspace_id
 
 
-def get_lakehouse_id(lakehouse_name, workspace_id, client):
-    """Get lakehouse ID by name"""
+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), None)
+    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}' not found")
+        raise ValueError(f"Lakehouse '{lakehouse_name_or_id}' not found")
     
     lakehouse_id = lakehouse_match['id']
-    print(f"✓ Found lakehouse: {lakehouse_name}")
+    print(f"✓ Found lakehouse: {lakehouse_name_or_id}")
     return lakehouse_id
 
 
@@ -266,14 +301,14 @@ def create_dataset_from_bim(dataset_name, bim_content, workspace_id, client):
                 raise Exception(f"Operation timed out")
 
 
-def deploy_semantic_model(workspace_name, lakehouse_name, schema_name, dataset_name, 
+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: Name of the target workspace
-        lakehouse_name: Name of the lakehouse
+        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
@@ -295,7 +330,7 @@ def deploy_semantic_model(workspace_name, lakehouse_name, schema_name, dataset_n
     try:
         # Step 1: Get workspace ID
         print("\n[Step 1/6] Getting workspace information...")
-        workspace_id = get_workspace_id(workspace_name, client)
+        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...")
@@ -320,7 +355,7 @@ def deploy_semantic_model(workspace_name, lakehouse_name, schema_name, dataset_n
         
         # Step 3: Get lakehouse ID
         print(f"\n[Step 3/6] Finding lakehouse...")
-        lakehouse_id = get_lakehouse_id(lakehouse_name, workspace_id, client)
+        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...")
@@ -346,8 +381,8 @@ def deploy_semantic_model(workspace_name, lakehouse_name, schema_name, dataset_n
         print("🎉 Deployment Completed!")
         print("=" * 70)
         print(f"Dataset: {dataset_name}")
-        print(f"Workspace: {workspace_name}")
-        print(f"Lakehouse: {lakehouse_name}")
+        print(f"Workspace: {workspace_name_or_id}")
+        print(f"Lakehouse: {lakehouse_name_or_id}")
         print(f"Schema: {schema_name}")
         print("=" * 70)
         
@@ -359,8 +394,8 @@ def deploy_semantic_model(workspace_name, lakehouse_name, schema_name, dataset_n
         print("=" * 70)
         print(f"Error: {str(e)}")
         print("\n💡 Troubleshooting:")
-        print(f"  - Verify workspace '{workspace_name}' exists")
-        print(f"  - Verify lakehouse '{lakehouse_name}' exists")
+        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)

{duckrun-0.2.9.dev1 → duckrun-0.2.9.dev3}/duckrun.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckrun
-Version: 0.2.9.dev1
+Version: 0.2.9.dev3
 Summary: Lakehouse task runner powered by DuckDB for Microsoft Fabric
 Author: mim
 License: MIT

{duckrun-0.2.9.dev1 → duckrun-0.2.9.dev3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "duckrun"
-version = "0.2.9.dev1"
+version = "0.2.9.dev3"
 description = "Lakehouse task runner powered by DuckDB for Microsoft Fabric"
 readme = "README.md"
 license = {text = "MIT"}