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

duckrun/core.py

@@ -133,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"  
@@ -195,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
@@ -242,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:
@@ -388,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)
             
@@ -407,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
@@ -420,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 = []
             
@@ -447,16 +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.")
 
     def _register_lookup_functions(self):
         """
@@ -599,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}")