cash: hashing error try

app.py

@@ -420,33 +420,61 @@ if submit_planning:
         @st.cache_data(hash_funcs={Tree: lambda _: None})
         def prepare_clustering_data(tree):
             try:
-                gc.collect()
+                # Log the start and basic info from the Tree
+                print("Starting clustering data preparation.")
+                total_nodes = len(tree.winning_nodes)
+                print(f"Total winning nodes: {total_nodes}")
+                print(f"Tree id: {id(tree)}")
+                
                 chunk_size = 10
                 super_cgrs_dict = {}
-                for i in range(0, len(tree.winning_nodes), chunk_size):
-                    chunk = list(tree.winning_nodes)[i:i+chunk_size]
-                    temp_dict = {node: tree.synthesis_route(node) for node in chunk}
+                
+                # Process winning nodes in chunks
+                for i in range(0, total_nodes, chunk_size):
+                    current_chunk = list(tree.winning_nodes)[i:i+chunk_size]
+                    print(f"Processing chunk {i // chunk_size + 1}: Nodes {current_chunk}")
+                    
+                    temp_dict = {}
+                    for node in current_chunk:
+                        try:
+                            # Log before processing each node
+                            print(f"Processing node {node}")
+                            route = tree.synthesis_route(node)
+                            temp_dict[node] = route
+                            print(f"Node {node} processed successfully (route length: {len(route)}).")
+                        except Exception as e:
+                            print(f"Error processing node {node}: {e}")
+                    
+                    # Log before calling reassign_nums_chunk
+                    print(f"Calling reassign_nums_chunk for nodes: {list(temp_dict.keys())}")
                     chunk_super_cgrs = reassign_nums_chunk(temp_dict)
                     super_cgrs_dict.update(chunk_super_cgrs)
+                    print(f"Chunk {i // chunk_size + 1} processed. Keys: {list(chunk_super_cgrs.keys())}")
+                    
                     del temp_dict
                     gc.collect()
                 
+                # Process reduced CGRs in chunks
                 reduced_super_cgrs_dict = {}
                 for i in range(0, len(super_cgrs_dict), chunk_size):
                     keys = list(super_cgrs_dict.keys())[i:i+chunk_size]
                     chunk_dict = {k: super_cgrs_dict[k] for k in keys}
+                    print(f"Reducing chunk for keys: {keys}")
                     reduced_chunk = process_all_rs_cgrs(chunk_dict)
                     reduced_super_cgrs_dict.update(reduced_chunk)
+                    print(f"Reduced chunk processed for keys: {list(reduced_chunk.keys())}")
+                    
                     del chunk_dict
                     gc.collect()
                 
-                del super_cgrs_dict
-                gc.collect()
+                print("Clustering data preparation complete.")
                 return reduced_super_cgrs_dict
             except Exception as e:
+                print(f"Error in prepare_clustering_data: {str(e)}")
                 st.error(f"Error in prepare_clustering_data: {str(e)}")
                 return None
 
+
         def memory_status():
             """Get current memory status"""
             process = psutil.Process()