duckrun 0.2.10.dev0__py3-none-any.whl → 0.2.11__py3-none-any.whl

duckrun/core.py

@@ -94,6 +94,7 @@ class Duckrun:
             pass  # Not in Colab, use default transport
         
         self._attach_lakehouse()
+        self._register_lookup_functions()
 
     @classmethod
     def connect(cls, connection_string: str, sql_folder: Optional[str] = None,
@@ -132,11 +133,8 @@ class Duckrun:
         
         # Check if it's a workspace-only connection (no "/" means workspace name only)
         if "/" not in connection_string:
-            print(f"Connecting to workspace '{connection_string}' for management operations...")
             return WorkspaceConnection(connection_string)
         
-        print("Connecting to Lakehouse...")
-        
         scan_all_schemas = False
         
         # Parse lakehouse connection string: "ws/lh.lakehouse/schema" or "ws/lh.lakehouse"  
@@ -194,17 +192,14 @@ class Duckrun:
         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) and guid_pattern.match(lakehouse_name):
-            print(f"✅ Names are already GUIDs: workspace={workspace_name}, lakehouse={lakehouse_name}")
             return workspace_name, lakehouse_name
         
         # Optimization: If workspace name has no spaces, use both names directly (old behavior)
         # Note: Lakehouse names cannot contain spaces in Microsoft Fabric, only workspace names can
         if " " not in workspace_name:
-            print(f"✅ Using names directly (workspace has no spaces): workspace={workspace_name}, lakehouse={lakehouse_name}")
             return workspace_name, lakehouse_name
         
         # Workspace name contains spaces - need to resolve both to GUIDs for proper ABFSS URLs
-        print(f"🔍 Resolving '{workspace_name}' workspace and '{lakehouse_name}' lakehouse to GUIDs (workspace has spaces)...")
         
         try:
             # Get authentication token using enhanced auth system
@@ -241,7 +236,6 @@ class Duckrun:
             if not lakehouse_id:
                 raise ValueError(f"Lakehouse '{lakehouse_name}' not found in workspace '{workspace_name}'")
             
-            print(f"✅ Resolved: {workspace_name} → {workspace_id}, {lakehouse_name} → {lakehouse_id}")
             return workspace_id, lakehouse_id
             
         except Exception as e:
@@ -387,7 +381,6 @@ class Duckrun:
                         tables_found.append((schema_name, table_name))
         else:
             # Scan specific schema only
-            print(f"🔍 Discovering tables in schema '{self.schema}'...")
             schema_path = f"{base_path}{self.schema}/"
             result = obs.list_with_delimiter(store, prefix=schema_path)
             
@@ -406,10 +399,6 @@ class Duckrun:
             tables = self._discover_tables_fast()
             
             if not tables:
-                if self.scan_all_schemas:
-                    print(f"No Delta tables found in {self.lakehouse_name}/Tables/")
-                else:
-                    print(f"No Delta tables found in {self.lakehouse_name}/Tables/{self.schema}/")
                 return
             
             # Group tables by schema for display
@@ -419,12 +408,6 @@ class Duckrun:
                     schema_tables[schema_name] = []
                 schema_tables[schema_name].append(table_name)
             
-            # Display tables by schema
-            print(f"\n📊 Found {len(tables)} tables:")
-            for schema_name in sorted(schema_tables.keys()):
-                table_list = sorted(schema_tables[schema_name])
-                print(f"   {schema_name}: {', '.join(table_list)}")
-            
             attached_count = 0
             skipped_tables = []
             
@@ -446,19 +429,9 @@ class Duckrun:
                 except Exception as e:
                     skipped_tables.append(f"{schema_name}.{table_name}")
                     continue
-            
-            print(f"\n{'='*60}")
-            print(f"✅ Ready - {attached_count}/{len(tables)} tables available")
-            if skipped_tables:
-                print(f"⚠ Skipped {len(skipped_tables)} tables: {', '.join(skipped_tables[:3])}{'...' if len(skipped_tables) > 3 else ''}")
-            print(f"{'='*60}\n")
                 
         except Exception as e:
             print(f"❌ Error attaching lakehouse: {e}")
-            print("Continuing without pre-attached tables.")
-        
-        # Register lookup functions as DuckDB UDFs
-        self._register_lookup_functions()
 
     def _register_lookup_functions(self):
         """
@@ -488,7 +461,7 @@ class Duckrun:
                 from .auth import get_fabric_api_token
                 token = get_fabric_api_token()
                 if not token:
-                    return f"[Error: No auth token]"
+                    return None
                 
                 url = "https://api.fabric.microsoft.com/v1/workspaces"
                 headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
@@ -503,9 +476,9 @@ class Duckrun:
                         self._name_cache['workspace_name_to_id'][name] = workspace_id
                         return name
                 
-                return f"[Workspace {workspace_id} not found]"
+                return None
             except Exception as e:
-                return f"[Error: {str(e)}]"
+                return None
         
         def get_lakehouse_name(workspace_id: str, lakehouse_id: str) -> str:
             """Get lakehouse display name from workspace ID and lakehouse ID (GUIDs)"""
@@ -517,7 +490,7 @@ class Duckrun:
                 from .auth import get_fabric_api_token
                 token = get_fabric_api_token()
                 if not token:
-                    return f"[Error: No auth token]"
+                    return None
                 
                 url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/lakehouses"
                 headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
@@ -533,9 +506,9 @@ class Duckrun:
                         self._name_cache['lakehouse_name_to_id'][lh_cache_key] = lakehouse_id
                         return name
                 
-                return f"[Lakehouse {lakehouse_id} not found]"
+                return None
             except Exception as e:
-                return f"[Error: {str(e)}]"
+                return None
         
         def get_workspace_id_from_name(workspace_name: str) -> str:
             """Get workspace ID (GUID) from workspace display name"""
@@ -546,7 +519,7 @@ class Duckrun:
                 from .auth import get_fabric_api_token
                 token = get_fabric_api_token()
                 if not token:
-                    return f"[Error: No auth token]"
+                    return None
                 
                 url = "https://api.fabric.microsoft.com/v1/workspaces"
                 headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
@@ -561,9 +534,9 @@ class Duckrun:
                         self._name_cache['workspace_id_to_name'][workspace_id] = workspace_name
                         return workspace_id
                 
-                return f"[Workspace '{workspace_name}' not found]"
+                return None
             except Exception as e:
-                return f"[Error: {str(e)}]"
+                return None
         
         def get_lakehouse_id_from_name(workspace_id: str, lakehouse_name: str) -> str:
             """Get lakehouse ID (GUID) from workspace ID and lakehouse display name"""
@@ -575,7 +548,7 @@ class Duckrun:
                 from .auth import get_fabric_api_token
                 token = get_fabric_api_token()
                 if not token:
-                    return f"[Error: No auth token]"
+                    return None
                 
                 url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/lakehouses"
                 headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
@@ -591,9 +564,9 @@ class Duckrun:
                         self._name_cache['lakehouse_id_to_name'][id_cache_key] = lakehouse_name
                         return lakehouse_id
                 
-                return f"[Lakehouse '{lakehouse_name}' not found]"
+                return None
             except Exception as e:
-                return f"[Error: {str(e)}]"
+                return None
         
         # Register functions in DuckDB
         try:
@@ -601,7 +574,6 @@ class Duckrun:
             self.con.create_function("get_lakehouse_name", get_lakehouse_name)
             self.con.create_function("get_workspace_id_from_name", get_workspace_id_from_name)
             self.con.create_function("get_lakehouse_id_from_name", get_lakehouse_id_from_name)
-            print("✅ Registered lookup functions: get_workspace_name, get_lakehouse_name, get_workspace_id_from_name, get_lakehouse_id_from_name")
         except Exception as e:
             print(f"⚠️  Warning: Could not register lookup functions: {e}")