duckrun 0.2.19.dev7__tar.gz → 0.2.20__tar.gz

{duckrun-0.2.19.dev7 → duckrun-0.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckrun
-Version: 0.2.19.dev7
+Version: 0.2.20
 Summary: Helper library for Fabric Python using duckdb, arrow and delta_rs (orchestration, queries, etc.)
 Author: mim
 License: MIT

{duckrun-0.2.19.dev7 → duckrun-0.2.20}/duckrun/auth.py

@@ -104,6 +104,8 @@ def _get_local_token() -> Optional[str]:
         
     except Exception as cli_error:
         print(f"⚠️ Azure CLI authentication failed: {cli_error}")
+        print("💡 TIP: Due to MFA requirements, you now need to login with scope:")
+        print("   az login --scope https://storage.azure.com/.default")
         print("🔐 Falling back to interactive browser authentication...")
         
         # Fallback to interactive browser
@@ -119,6 +121,7 @@ def _get_local_token() -> Optional[str]:
             
         except Exception as browser_error:
             print(f"❌ Interactive browser authentication failed: {browser_error}")
+            print("💡 Please run: az login --scope https://storage.azure.com/.default")
             return None
 
 

{duckrun-0.2.19.dev7 → duckrun-0.2.20}/duckrun/core.py

@@ -1035,6 +1035,21 @@ class Duckrun(WorkspaceOperationsMixin):
         """Get underlying DuckDB connection"""
         return self.con
 
+    def register(self, name: str, df):
+        """
+        Register a pandas DataFrame as a virtual table in DuckDB.
+        
+        Args:
+            name: Name for the virtual table
+            df: pandas DataFrame to register
+            
+        Example:
+            con = duckrun.connect("workspace/lakehouse.lakehouse")
+            con.register("tb", df)
+            con.sql("SELECT * FROM tb").show()
+        """
+        self.con.register(name, df)
+
     def get_stats(self, source: str = None, detailed = False):
         """
         Get comprehensive statistics for Delta Lake tables.
@@ -1234,9 +1249,11 @@ class Duckrun(WorkspaceOperationsMixin):
                 dataset_name = self.schema  # Use schema name
         
         # Call the deployment function (DirectLake only)
+        # Use lakehouse_id (with .ItemType suffix) instead of lakehouse_name (without suffix)
+        # This ensures proper item resolution for non-lakehouse items like .SnowflakeDatabase
         return deploy_semantic_model(
             workspace_name_or_id=self.workspace,
-            lakehouse_name_or_id=self.lakehouse_name,
+            lakehouse_name_or_id=self.lakehouse_id,
             schema_name=self.schema,
             dataset_name=dataset_name,
             bim_url_or_path=bim_url,
@@ -1244,6 +1261,69 @@ class Duckrun(WorkspaceOperationsMixin):
             refresh=refresh
         )
 
+    def export_ducklake_to_delta(self, db_path: str, data_root: str = None) -> bool:
+        """
+        Export DuckLake metadata to Delta Lake format for Spark compatibility.
+        
+        Reads a DuckLake database file from the Files section and generates Delta Lake
+        checkpoint files and JSON logs for all tables, making them readable by Spark
+        and other Delta Lake tools.
+        
+        Args:
+            db_path: Relative path to DuckLake DB file in Files section (e.g., "db/test/test.db")
+            data_root: Optional base path for lakehouse data. If None, reads from DuckLake metadata.
+        
+        Returns:
+            True if export succeeded, False otherwise
+        
+        Examples:
+            con = duckrun.connect("workspace/lakehouse.lakehouse/dbo")
+            
+            # Export DuckLake tables to Delta format
+            con.export_ducklake_to_delta("meta.db")
+            
+            # With explicit data root
+            con.export_ducklake_to_delta("db/ducklake.db", data_root="abfss://...")
+        """
+        from .ducklake_metadata import generate_latest_delta_log
+        import obstore as obs
+        from obstore.store import AzureStore
+        
+        # Construct full ABFSS path to DB file in Files section
+        full_db_path = f"{self.files_base_url}{db_path}"
+        
+        print(f"🔍 Exporting DuckLake metadata from: {db_path}")
+        print(f"📂 Full DB path: {full_db_path}")
+        
+        # Get Azure token
+        from .auth import get_token
+        token = self._get_storage_token()
+        if token == "PLACEHOLDER_TOKEN_TOKEN_NOT_AVAILABLE":
+            print("Authenticating with Azure for DuckLake export...")
+            token = get_token()
+            if not token:
+                print("❌ Failed to authenticate for DuckLake export")
+                return False
+        
+        # Setup OneLake store for uploading checkpoint files
+        # Use table_base_url as the base since we'll be writing to Tables section
+        store = AzureStore.from_url(self.table_base_url, bearer_token=token)
+        
+        # If data_root not provided, use table_base_url (which includes /Tables/)
+        # This will be used to construct full paths for checkpoint files
+        if data_root is None:
+            data_root = self.table_base_url.rstrip('/')
+        
+        try:
+            generate_latest_delta_log(full_db_path, data_root, store, token)
+            print(f"✅ DuckLake export completed successfully")
+            return True
+        except Exception as e:
+            print(f"❌ DuckLake export failed: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+
     def rle(self, table_name: str = None, mode = "natural",
             min_distinct_threshold: int = 2, max_cardinality_pct: float = 0.01,
             max_ordering_depth: int = 3, limit: int = None):
@@ -1677,4 +1757,13 @@ class WorkspaceConnection(WorkspaceOperationsMixin):
             print(f"❌ Error downloading semantic model: {e}")
             import traceback
             traceback.print_exc()
-            return None
+            return None
+    
+    def close(self):
+        """
+        Close the workspace connection.
+        
+        Note: WorkspaceConnection doesn't maintain persistent connections,
+        so this is a no-op for compatibility with code patterns that call close().
+        """
+        pass