Add files using upload-large-folder tool

script.py

@@ -14,7 +14,7 @@ def get_all_source_folders(scrape_dir):
         print(f"Error: Scrape directory '{scrape_dir}' does not exist.")
         return source_folders
 
-    # Walk through the entire directory tree
+    # Walk through the entire directory tree to map every available source folder
     for root, dirs, files in os.walk(scrape_dir):
         for d in dirs:
             source_folders[d].append(os.path.join(root, d))
@@ -25,84 +25,109 @@ def get_subfolder_names(folder_path):
     """Returns a list of subfolder names immediately inside a given directory."""
     return [d for d in os.listdir(folder_path) if os.path.isdir(os.path.join(folder_path, d))]
 
-def process_folders(scrape_dir, dest_root_path):
-    # 1. Scrape all folders from the source directory
+def process_folders(scrape_dir, dest_root_path, dry_run=True):
+    # 1. Scrape all folders from the source directory to build our lookup map
     source_folders = get_all_source_folders(scrape_dir)
     if not source_folders:
         print("No source folders found.")
         return
 
-    # 2. Find matching folders in the destination root path (Second-to-last level)
-    dest_matches = defaultdict(list)
-    for root, dirs, files in os.walk(dest_root_path):
-        for d in dirs:
-            if d in source_folders:
-                dest_matches[d].append(os.path.join(root, d))
+    if not os.path.exists(dest_root_path):
+        print(f"Error: Destination root '{dest_root_path}' does not exist.")
+        return
+
+    print("=" * 60)
+    print(f"MODE: {'DRY RUN (Mapping Only)' if dry_run else 'EXECUTION (Copying Files)'}")
+    print("=" * 60)
 
     # Pattern to extract the date and hour: YYYY-MM-DD_HH
     file_pattern = re.compile(r'^(\d{4}-\d{2}-\d{2}_\d{2})-\d{2}-\d{2}')
 
-    # 3. Process each matched robot folder
-    for folder_name, dest_paths in dest_matches.items():
-        # Check for multiple destination matches to avoid conflicts
-        if len(dest_paths) > 1:
-            print(f"NOTICE: Found {len(dest_paths)} destination matches for '{folder_name}'. Skipping.")
+    # 2. Iterate exactly to the second level of the destination directory
+    for level1 in os.listdir(dest_root_path):
+        level1_path = os.path.join(dest_root_path, level1)
+        if not os.path.isdir(level1_path):
             continue
             
-        src_paths = source_folders[folder_name]
-        # Check for multiple source matches
-        if len(src_paths) > 1:
-            print(f"NOTICE: Found {len(src_paths)} source matches for '{folder_name}'. Skipping.")
-            continue
-        
-        dest_path = dest_paths[0]
-        src_path = src_paths[0]
+        for level2 in os.listdir(level1_path):
+            dest_path = os.path.join(level1_path, level2)
+            if not os.path.isdir(dest_path):
+                continue
 
-        # 4. Get the last level subfolders (e.g., 'camera') from the source
-        # We NO LONGER check if these exist in the destination first.
-        src_subfolders = get_subfolder_names(src_path)
+            folder_name = level2
 
-        # 5. Process files INSIDE the source subfolders
-        for subfolder in src_subfolders:
-            src_sub_path = os.path.join(src_path, subfolder)
-            dest_sub_path = os.path.join(dest_path, subfolder)
+            # 3. Look up the destination folder in our source map
+            src_paths = source_folders.get(folder_name, [])
+            
+            # 4. Handle matching conditions
+            if not src_paths:
+                if dry_run:
+                    print(f"[UNMATCHED] Dest: '{folder_name}' -> No source found.")
+                continue
+                
+            if len(src_paths) > 1:
+                print(f"[CONFLICT]  Dest: '{folder_name}' -> Matches {len(src_paths)} sources. Skipping.")
+                if dry_run:
+                    for p in src_paths:
+                        print(f"            - {p}")
+                continue
 
-            # Ensure the camera folder exists in the destination before copying
-            os.makedirs(dest_sub_path, exist_ok=True)
+            # We have exactly one match
+            src_path = src_paths[0]
 
-            # Get all files in this specific source subfolder and sort chronologically
-            files = [f for f in os.listdir(src_sub_path) if os.path.isfile(os.path.join(src_sub_path, f))]
-            files.sort() 
-            
-            selected_files = {}
-            for file_name in files:
-                match = file_pattern.search(file_name)
-                if match:
-                    hour_key = match.group(1)
-                    if hour_key not in selected_files:
-                        selected_files[hour_key] = file_name
-
-            # 6. Copy the filtered files while checking for duplicates
-            copied_count = 0
-            for file_name in selected_files.values():
-                src_file = os.path.join(src_sub_path, file_name)
-                dest_file = os.path.join(dest_sub_path, file_name)
+            if dry_run:
+                print(f"[MAPPED]    Dest: '{folder_name}' \n            <- Source: '{src_path}'")
+                continue # Skip the actual file processing during a dry run
+
+            # ---------------------------------------------------------
+            # The following code only runs if dry_run=False
+            # ---------------------------------------------------------
+
+            # 5. Get the subfolders (e.g., 'camera') from the source
+            src_subfolders = get_subfolder_names(src_path)
+
+            # 6. Process files INSIDE the source subfolders
+            for subfolder in src_subfolders:
+                src_sub_path = os.path.join(src_path, subfolder)
+                dest_sub_path = os.path.join(dest_path, subfolder)
+
+                # Ensure the camera folder exists in the destination
+                os.makedirs(dest_sub_path, exist_ok=True)
+
+                # Get files and sort chronologically
+                files = [f for f in os.listdir(src_sub_path) if os.path.isfile(os.path.join(src_sub_path, f))]
+                files.sort() 
                 
-                # Skip if file was already copied
-                if os.path.exists(dest_file):
-                    continue
+                selected_files = {}
+                for file_name in files:
+                    match = file_pattern.search(file_name)
+                    if match:
+                        hour_key = match.group(1)
+                        if hour_key not in selected_files:
+                            selected_files[hour_key] = file_name
+
+                # 7. Copy the filtered files while checking for duplicates
+                copied_count = 0
+                for file_name in selected_files.values():
+                    src_file = os.path.join(src_sub_path, file_name)
+                    dest_file = os.path.join(dest_sub_path, file_name)
                     
-                shutil.copy2(src_file, dest_file)
-                copied_count += 1
-                
-            if copied_count > 0:
-                print(f"Copied {copied_count} new files into '{folder_name}/{subfolder}'.")
+                    if os.path.exists(dest_file):
+                        continue
+                        
+                    shutil.copy2(src_file, dest_file)
+                    copied_count += 1
+                    
+                if copied_count > 0:
+                    print(f"Copied {copied_count} new files into '{folder_name}/{subfolder}'.")
             
     print("\nProcess completed.")
 
 if __name__ == "__main__":
     # Define your paths here
-    SCRAPE_DIRECTORY = "../Datasets/" 
-    DESTINATION_ROOT = "Roots"
+    SCRAPE_DIRECTORY = "/media/ngaggion/DATA/Raices/Datasets" 
+    DESTINATION_ROOT = "/media/ngaggion/DATA/Raices/NewData/ArabidopsisDataset"
     
-    process_folders(SCRAPE_DIRECTORY, DESTINATION_ROOT)
+    # Run first with dry_run=True to see the mappings. 
+    # Change to False when you are ready to copy files.
+    process_folders(SCRAPE_DIRECTORY, DESTINATION_ROOT, dry_run=False)