I have just started creating a python module to load all the images in a path, do some…
- User
I have just started creating a python module to load all the images in a path, do some basic processing, load a caption file if one exists(same filename but with the extension .txt or .caption instead, for example, "image205.png" would have a caption file "image205.txt" or "image205.caption", and done in a way to allow further extension types with unique loading to be done) For now, my skeleton code looks like this:
from typing import List class Caption: caption: str class Image: image_file: str width: int height: int captions: List[Caption] def load_path(path: str) -> List[Image]: images = [] return imagesPlease do it in a step-by-step way and return the completed code in full.
- Assistant
To create a Python module that loads images, processes them, and loads associated caption files, we will need to add several functionalities to your current skeleton code. We shall implement the following steps:
- List all the files in the given path.
- Filter out the image files (e.g., based on common image extensions).
- Load the image file and perform basic processing (e.g., fetch its dimensions).
- For each image file, check if the corresponding caption file exists, and load the caption.
- Structure the data into
ImageandCaptionobjects and collect them into a list. - Allow for extension of distinct loading mechanisms for different caption file types.
- Return the list of
Imageobjects populated with the correspondingCaption.
Here's the complete code that accomplishes this:
import os from typing import List, Optional, Union from PIL import Image as PILImage class Caption: def __init__(self, caption: str): self.caption = caption class Image: def __init__(self, image_file: str, width: int, height: int, captions: List[Caption] = None): self.image_file = image_file self.width = width self.height = height self.captions = captions if captions else [] def load_caption(file: str) -> Optional[Caption]: if os.path.exists(file): with open(file, 'r') as f: caption_text = f.read().strip() return Caption(caption_text) return None def load_image(image_path: str) -> PILImage.Image: # Load the image and perform any necessary processing image = PILImage.open(image_path) return image def load_path(path: str) -> List[Image]: images = [] # Dictionary to store extension specific methods for loading caption caption_loaders = { '.txt': load_caption, '.caption': load_caption # Add any other caption loaders for new extension types here } # Acceptable image extensions image_extensions = ('.png', '.jpg', '.jpeg', '.bmp', '.gif') # List all files in the given directory for file in os.listdir(path): file_path = os.path.join(path, file) # Check if it's an image if file.lower().endswith(image_extensions): pil_image = load_image(file_path) # Create a new Image instance image = Image( image_file=file, width=pil_image.width, height=pil_image.height ) # Check for corresponding caption files for ext, loader in caption_loaders.items(): caption_filename = os.path.splitext(file_path)[0] + ext caption = loader(caption_filename) if caption: image.captions.append(caption) images.append(image) return images # Example usage: if __name__ == "__main__": images = load_path('path/to/images') for img in images: print(f'Image file: {img.image_file} - Width: {img.width}, Height: {img.height}') for caption in img.captions: print(f'Caption: {caption.caption}')Some notable things in the above code:
- We use
PILfrom thePillowlibrary to handle images. You will need to installPillowif not already installed (pip install Pillow). - The
load_captionfunction handles opening and reading caption files. - The
load_imagefunction is a placeholder to process the images as needed. For now, it just opens the image, but you can add additional processing as required. - The
load_pathfunction orchestrates the whole process. It filters out image files, loads images, checks for caption files with the given extensions, and collects everything into a list ofImageobjects. - For simplicity, the
ImageandCaptionclasses have been changed to use simple initializers instead of thedataclassdecorator, but you may implementdataclassif you prefer.
You would replace
'path/to/images'with the actual path to where your images are stored. This code forms a good starting point for a module that loads images and their captions. You can extend and modify it according to your project's specific needs. - User
Can pillow handle .webp?
- Assistant
Yes, Pillow can handle
.webpimage files. The WebP format is a modern image format that provides superior lossless and lossy compression for images on the web. Pillow added support for WebP in version 2.9.0 (July 1, 2015), and since then, it has been possible to open and manipulate WebP images using thePillowlibrary in Python.Here is an example of how you would open a
.webpimage with Pillow:from PIL import Image # Load the WebP image file image_path = 'path/to/image.webp' webp_image = Image.open(image_path) # Display the image webp_image.show() # Perform operations as with any other image format webp_image = webp_image.rotate(90) # Example: Rotate the image by 90 degrees # Save the image in a different format, if desired webp_image.save('path/to/image_converted.jpg')Ensure you have the WebP library installed on your system if you're working with WebP images. If you encounter any issues with handling WebP images using Pillow, you might need to ensure that both Pillow and your system's WebP library are up-to-date.
To check your Pillow version, you can run:
pip show pillowOr in Python:
import PIL print('Pillow version:', PIL.__version__)If necessary, update Pillow using:
pip install --upgrade pillowRemember, you can easily add
.webpto your list of accepted image extensions in theimage_extensionstuple in the provided module code:image_extensions = ('.png', '.jpg', '.jpeg', '.bmp', '.gif', '.webp') - User
How best would I implement a way of gathering all the images based on matching caption text? Like, say I wanted to see if a caption contained "male", but on a per word basis, so it wouldn't match "female" and it wouldn't match "male_only", but it would match "male only", I would want a fairly robust search system so I could also search for "*male", which would then match both "male" and "female", but not "male_only", but "male" would match "male", "female" AND "male_only". I would also want to exclude terms, for example, if I wanted to exclude "male" from any matches, I could do "-male", and now if it finds "male" in the caption, it will reject including the image in the returned list, even if it matches the other terms, but again, it won't exclude "female" or "male_only", it will only exclude it if it matches "male" directly.
- Assistant
Implementing a robust search system with inclusion and exclusion criteria for filtering images based on caption text involves writing a more complex search function. To achieve this, we need to consider word boundaries for direct matches and also allow for pattern-based matches (e.g., wildcards).
We can use regular expressions (regex) to provide the search functionality for pattern matching, including the wildcards and exclusion terms as specified. The Python
remodule offers functions that make it possible to check for matching patterns.Here's an updated code snippet that provides this functionality:
import re from typing import List # Other class definitions remain the same... def regex_from_pattern(pattern: str) -> str: ''' Convert a search pattern like "*male" to a regex pattern like ".*\\bmale\\b" (word boundary) ''' # Escape all regex special characters except asterisk (*) pattern = re.escape(pattern).replace('\\*', '.*') # Add word boundaries for exact word matching without asterisk if not pattern.startswith('.*'): pattern = '\\b' + pattern if not pattern.endswith('.*'): pattern += '\\b' return pattern def match_caption(caption: Caption, include_patterns: List[str], exclude_patterns: List[str]) -> bool: ''' Check if caption matches include patterns and doesn't match exclude patterns ''' for pattern in exclude_patterns: regex_pattern = regex_from_pattern(pattern) if re.search(regex_pattern, caption.caption): # Exclude the caption if it matches an exclude pattern return False for pattern in include_patterns: regex_pattern = regex_from_pattern(pattern) if not re.search(regex_pattern, caption.caption): # If a required include pattern is not found, return False return False return True def search_with_patterns(images: List[Image], include_patterns: List[str], exclude_patterns: List[str]) -> List[Image]: matched_images = [] for image in images: if any(match_caption(caption, include_patterns, exclude_patterns) for caption in image.captions): matched_images.append(image) return matched_images # Loading images from path would be the same as before... # Example usage if __name__ == "__main__": images = load_path('path/to/images') # Example search parameters include_patterns = ["*male", "*happy*"] # Want these patterns to be included exclude_patterns = ["-male", "-sad"] # Want these patterns to be excluded matched_images = search_with_patterns(images, include_patterns, exclude_patterns) for img in matched_images: print(f'Image file: {img.image_file}') for caption in img.captions: print(f'Caption: {caption.caption}')Here's what the above functions do:
regex_from_patternfunction converts a search pattern into a regex pattern suitable for matching whole words, with special handling for the wildcards (*).match_captionfunction takes aCaptionobject and a list of include and exclude patterns and returns True if the caption matches all include patterns and none of the exclude patterns.search_with_patternstakes the whole list ofImageobjects and the search patterns and filters the images based on their captions.
This code supports the use of
*as a wildcard that matches any number of characters, and-as an indicator for exclusion. It takes care to match the whole words unless wildcards are used.For example, a pattern
malewould match only the exact word "male", while*malewould match "female" and "male", and*male*would match "male", "female" and "male_only". Exclude patterns that start with-will be used to exclude any captions that exactly match the subsequent term.Note: Regular expressions are powerful and can be complex, so ensure your search patterns are correctly formulated to avoid unexpected matches or no matches. Regular expression patterns that contain special characters should be constructed with care.
- User
if you have two separate lists for include and exclude, it doesn't make sense to have the "-", either it should be one list that automatically determines if a term includes wildcards, or is excluded with "-", or keep it to two lists, but remove the need for "-".
- Assistant
Apologies for the confusion. You are correct; if you have two separate lists for including and excluding terms, the
-prefix for the exclude patterns is unnecessary. Let's correctly approach this with two distinct lists and drop the-prefix for exclusion.Here's how the search functionality should be updated:
import re from typing import List # Other class definitions remain the same... def regex_from_pattern(pattern: str) -> str: ''' Convert a search pattern like "*male" to a regex pattern like ".*\\bmale\\b" (word boundary) ''' # Escape all regex special characters except asterisk (*) pattern = re.escape(pattern).replace('\\*', '.*') # Add word boundaries for exact word matching without asterisk if not pattern.startswith('.*'): pattern = '\\b' + pattern if not pattern.endswith('.*'): pattern += '\\b' return pattern def match_caption(caption: Caption, include_patterns: List[str], exclude_patterns: List[str]) -> bool: ''' Check if caption matches include patterns and doesn't match exclude patterns ''' caption_text = caption.caption # Exclude the caption if it matches any exclude pattern for pattern in exclude_patterns: regex_pattern = regex_from_pattern(pattern) if re.search(regex_pattern, caption_text): return False # If there are include patterns, ensure at least one matches if include_patterns and not any(re.search(regex_from_pattern(pattern), caption_text) for pattern in include_patterns): return False # If there are no include patterns, we assume it's a match if it passed exclude checks return True def search_with_patterns(images: List[Image], include_patterns: List[str], exclude_patterns: List[str]) -> List[Image]: matched_images = [] for image in images: if any(match_caption(caption, include_patterns, exclude_patterns) for caption in image.captions): matched_images.append(image) return matched_images # Example usage if __name__ == "__main__": images = load_path('path/to/images') # Example search parameters include_patterns = ["*male", "*happy*"] # Want these patterns to be included exclude_patterns = ["male", "sad"] # Want to exclude these exact words matched_images = search_with_patterns(images, include_patterns, exclude_patterns) for img in matched_images: print(f'Image file: {img.image_file}') for caption in img.captions: print(f'Caption: {caption.caption}')In this updated approach, we have separate lists for inclusion and exclusion criteria without the
-prefix. Thematch_captionfunction first checks for matches against theexclude_patternslist, which immediately disqualifies a caption if a pattern matches. It then checks theinclude_patternslist to ensure at least one pattern matches the caption.With this design, the search is clear and there is no ambiguity in whether a term is intended to include or exclude matches, improving the clarity and robustness of your search system.
- User
Can you put the code in a code block so it doesn't lose special characters?
- Assistant
Certainly! Here's the improved search functionality enclosed in a code block that preserves the special characters:
import re from typing import List # Other class definitions remain the same... def regex_from_pattern(pattern: str) -> str: ''' Convert a search pattern like "*male" to a regex pattern like ".*\\bmale\\b" (word boundary) ''' # Escape all regex special characters except asterisk (*) pattern = re.escape(pattern).replace('\\*', '.*') # Add word boundaries for exact word matching without asterisk if not pattern.startswith('.*'): pattern = '\\b' + pattern if not pattern.endswith('.*'): pattern += '\\b' return pattern def match_caption(caption: Caption, include_patterns: List[str], exclude_patterns: List[str]) -> bool: ''' Check if caption matches include patterns and doesn't match exclude patterns ''' caption_text = caption.caption # Exclude the caption if it matches any exclude pattern for pattern in exclude_patterns: regex_pattern = regex_from_pattern(pattern) if re.search(regex_pattern, caption_text): return False # If there are include patterns, ensure at least one matches if include_patterns and not any(re.search(regex_from_pattern(pattern), caption_text) for pattern in include_patterns): return False # If there are no include patterns, we assume it's a match if it passed exclude checks return True def search_with_patterns(images: List[Image], include_patterns: List[str], exclude_patterns: List[str]) -> List[Image]: matched_images = [] for image in images: if any(match_caption(caption, include_patterns, exclude_patterns) for caption in image.captions): matched_images.append(image) return matched_images # Example usage if __name__ == "__main__": images = load_path('path/to/images') # Example search parameters include_patterns = ["*male", "*happy*"] # Want these patterns to be included exclude_patterns = ["male", "sad"] # Want to exclude these exact words matched_images = search_with_patterns(images, include_patterns, exclude_patterns) for img in matched_images: print(f'Image file: {img.image_file}') for caption in img.captions: print(f'Caption: {caption.caption}')This code should function as intended to filter the captions based on inclusion and exclusion terms. Capture terms that match patterns in the
exclude_patternslist will disqualify the associated images, while only images whose captions match at least one term in theinclude_patternslist will be included in the results.Remember to execute the function
load_path('path/to/images')where you have the image files, and adjust theinclude_patternsandexclude_patternslists to your search criteria. - User
because I am losing the formatting in this chat interface, for all special characters, just in the function "regex_from_pattern", can you replace the special characters with more long form words in place of the special characters? like for
*, surround it with back ticks: "`" - Assistant
Certainly! I will replace the special characters with more long-form words within backticks to prevent formatting issues. Here's the updated
regex_from_patternfunction with this change:def regex_from_pattern(pattern: str) -> str: ''' Convert a search pattern like "`*`male" to a regex pattern like ".*\\b"male"\\b" (word boundary) ''' # Escape all regex special characters except asterisk (`*`) pattern = re.escape(pattern).replace('\\`*`', '.*') # Add word boundaries for exact word matching without asterisk (`*`) if not pattern.startswith('.*'): pattern = '\\b' + pattern if not pattern.endswith('.*'): pattern += '\\b' return patternNow, whenever you see "
*", it represents the asterisk character in the pattern, and the double backslashes are used to indicate a single backslash in the regular expression, which is a common escape character in regex patterns.Remember to make consistent adjustments when implementing the search functionality to avoid confusion with the literal interpretation of these long-form special characters.
- User
interesting that it doesn't support spaces, for example, this is what I used for my main part of the example usage, as a test run:
if __name__ == "__main__": images = load_path(R'D:\AI Generation\Projects\Training\Concept\POV v0.3\img\1_cowgirl position art') print(f"Found {len(images)} images") capcount = 0 for img in images: for caption in img.captions: capcount += 1 print(f"Found {capcount} captions") # Example search parameters include_patterns = ["comic book character"] # Want these patterns to be included exclude_patterns = ["censored"] # Want to exclude these exact words matched_images = search_with_patterns(images, include_patterns, exclude_patterns) print(f"Matched {len(matched_images)} images")In that folder there is 309 files: 103 images, 103 captions and 103 cached latents.
The output from this is:
(venv) (base) PS D:\AI Generation\Projects\ai-webui\aidili-fastreact\backend> python .\dataset.py Found 103 images Found 103 captions Matched 0 imagesIt isn't matching any captions, I also added a print for if an excluded match is found:
def match_caption(caption: Caption, include_patterns: List[str], exclude_patterns: List[str]) -> bool: ''' Check if caption matches include patterns and doesn't match exclude patterns ''' caption_text = caption.caption # Exclude the caption if it matches any exclude pattern for pattern in exclude_patterns: regex_pattern = regex_from_pattern(pattern) if re.search(regex_pattern, caption_text): print(f"Matched exclude pattern `{pattern}` in caption: `{caption_text}`") return False # If there are include patterns, ensure at least one matches if include_patterns and not any(re.search(regex_from_pattern(pattern), caption_text) for pattern in include_patterns): return False # If there are no include patterns, we assume it’s a match if it passed exclude checks return TrueSo I know it isn't matching the excluded patterns.
Here is an example of one of the caption files that should match:
1boy, 1girl, arm grab, big breasts, black hair, blue eyes, breasts, comic book character, cowgirl position, demigod, diana prince, female focus, girl on top, high res, justice league unlimited, long hair, male/female, mature, mature female, patreon, patreon paid, patreon reward, pov, spread legs, sunsetriders7, superheroine, tagme, wonder womanAs you can see, the caption does contain "comic book character", but it isn't being matched.
- Assistant
Thank you for providing the context and examples. Based on the caption provided and your search parameters, it's clear that you intend to match the exact phrase "comic book character" within the captions. This means the regular expressions need to account for multiple words, and the word-boundary markers (
\b) need to be placed correctly.Let me adjust the
regex_from_patternfunction to accommodate the search for exact phrases and ensure that spaces within the phrases are handled correctly:import re from typing import List class Caption: def __init__(self, caption: str): self.caption = caption class Image: def __init__(self, image_file: str, width: int, height: int, captions: List[Caption] = None): self.image_file = image_file self.width = width self.height = height self.captions = captions if captions else [] def regex_from_pattern(pattern: str) -> str: ''' Convert a search pattern to a regex pattern ensuring phrase search ''' # If the pattern starts or ends with `*`, match any characters before or after pattern = re.escape(pattern) if pattern.startswith("\\`*`"): pattern = ".*" + pattern[4:] else: pattern = "\\b" + pattern if pattern.endswith("\\`*`"): pattern = pattern[:-4] + ".*" else: pattern += "\\b" # Replace escaped spaces with literal spaces for phrase matching pattern = pattern.replace("\\ ", " ") return pattern def match_caption(caption: Caption, include_patterns: List[str], exclude_patterns: List[str]) -> bool: ''' Check if caption text matches include patterns and doesn't match exclude patterns ''' caption_text = caption.caption.lower() # Convert caption to lowercase to match case-insensitively # Exclude the caption if it matches an exclude pattern for pattern in exclude_patterns: regex_pattern = regex_from_pattern(pattern) if re.search(regex_pattern, caption_text): return False # Ensure the caption matches all include patterns for pattern in include_patterns: regex_pattern = regex_from_pattern(pattern) if not re.search(regex_pattern, caption_text): return False return True def search_with_patterns(images: List[Image], include_patterns: List[str], exclude_patterns: List[str]) -> List[Image]: matched_images = [] for image in images: for caption in image.captions: if match_caption(caption, include_patterns, exclude_patterns): matched_images.append(image) break # Once the image matches, we do not need to check other captions return matched_images # Load images and perform the search just like in the previous examples...I made the following changes:
- The
regex_from_patternfunction now unescapes spaces within patterns to ensure that the exact phrases are matched. - The patterns are converted to lowercase by the
match_captionfunction to perform case-insensitive matching (caption_textis also converted to lowercase).
Make sure to use the above
regex_from_patternfunction with these considerations when looking to match exact phrases within the captions. This should yield the expected results when searching for captions containing "comic book character" and not containing "censored". - The
- User
Unfortunately I don't think the formatting is showing up for me, all I see is:
def regex_from_pattern(pattern: str) -> str: ‘’’ Convert a search pattern to a regex pattern ensuring phrase search ‘’‘ # If the pattern starts or ends with *, match any characters before or after pattern = re.escape(pattern) if pattern.startswith(“\*”): pattern = “." + pattern[4:] else: pattern = “\b” + pattern if pattern.endswith(“\*”): pattern = pattern[:-4] + ".” else: pattern += “\b” # Replace escaped spaces with literal spaces for phrase matching pattern = pattern.replace("\ ", " ") return patternIf there is any special characters missing, please replace them with a long form in place, for example * becomes ASTERIX, do this for ALL special characters.
The main issue I have is the
pattern[4:]andpattern[:-4]parts, if I don't fully understand the purpose of those lines, for me, it seems like we are replacing 2 characters,\*with., but we are also stripping 4 characters off the front, so if the pattern was*male, it would turn into.le\b, as re.escape escapes the*, so it strips off the first 4 characters:\*ma, am I wrong? - Assistant
I apologize for any confusion. Let me clarify.
The
[4:]and[:-4]indeed would not be correct if you're starting with a two-character string like\*. My intention was to handle unescaped asterisks that become four characters long when escaped as\\*, but since we're using backticks to avoid formatting problems, we should handle it accordingly.Here's a corrected version of the
regex_from_patternfunction with all special characters replaced with their long-form placeholders for clarity:def regex_from_pattern(pattern: str) -> str: """ Convert a search pattern to a regex pattern ensuring phrase search. ASTERISK represents the asterisk (*). DOT represents a period (.). BACKSLASH_B represents a word boundary marker (\b). """ # If the pattern starts or ends with `*`, match any characters before or after pattern = re.escape(pattern) if pattern.startswith("\\`ASTERISK`"): pattern = "DOTAST" + pattern[10:] # Remove the "\`ASTERISK`" after escaping else: pattern = "BACKSLASH_B" + pattern if pattern.endswith("\\`ASTERISK`"): pattern = pattern[:-10] + "DOTAST" else: pattern += "BACKSLASH_B" # Replace escaped spaces with literal spaces for phrase matching pattern = pattern.replace("\\ ", " ") return patternNote in the comments,
DOTASTstands for.*which matches any character (except for line terminators) zero or more times.BACKSLASH_Bstands for word boundary\b.Let's also clarify the "start" and "end" replacement within the pattern:
-
The start: When the pattern starts with the escaped version of "
*", which is "\ASTERISK", this is a 10 character string after escaping (with backticks taken into account). We want to replace this with ".*", not a single period. -
The end: Similar to the start, when the pattern ends with "\
ASTERISK", we want to drop the last 10 characters and append ".*".
These changes now account for the use of backticks (
) in the pattern, which represent the asterisk (*) to avoid chat formatting issues. When translating the pattern into regex, you would replaceDOTASTwith.andBACKSLASH_Bwith\b. Here's an example of this process where we would translateDOTASTback to.`:regex_string = regex_from_pattern("`*`male") # When interpreting `regex_string`, replace `DOTAST` with `.*` and `BACKSLASH_B` with `\b` # so it becomes '.*\bmale\b'If this concept works well for you, be sure to also update the matching functions to interpret these placeholders (
DOTASTandBACKSLASH_B) back into their regex equivalents before conducting the search.Since we cannot share backslashes and other regex special characters directly without potentially losing formatting, please ensure you rewrite the "long-form" words back into their appropriate regex syntax if you copy this code into your editor or IDE.
-
- User
From a file path like:
D:\AI Generation\_Repository\training datasets\_Downloads\mother_and_daughter\00ed6598a83b9bef270d9b5ff7c6dc6c.jpgI want to copy the image file to a new location with the same file name, including the caption file, here is my skeleton code within the main part of the .py file:# Copy matched images to new location copy_to = R'D:\AI Generation\Projects\Training\Concept\POV Sex v0.4\img\1_handjob art' for img in matched_images: print(f"Copying {img.image_file}") - Assistant
To copy image files and their corresponding caption files to a new location, you'll need to use the
shutilmodule in Python, which provides acopyfunction. You also need to determine the paths for the source image, source caption (if one exists), and the destination paths for both. Here's how you can include this functionality in your existing code:import shutil import os # ... (your existing class definitions and functions) def copy_file(src, dst): """ Copy a file from the src path to the dst path. Parent directories of the destination will be created if they do not already exist. :param src: Source file path :param dst: Destination file path """ os.makedirs(os.path.dirname(dst), exist_ok=True) shutil.copy(src, dst) def copy_image_and_caption(image: Image, src_dir: str, dest_dir: str, caption_extensions=('.txt', '.caption')): """ Copy an image and its corresponding caption file to a new directory. :param image: Image object :param src_dir: Source directory where the images and captions are currently stored :param dest_dir: Destination directory to copy the images and captions to :param caption_extensions: Tuple of caption file extensions to check for """ # Copy the image file src_image_path = os.path.join(src_dir, image.image_file) dest_image_path = os.path.join(dest_dir, image.image_file) copy_file(src_image_path, dest_image_path) print(f"Copied image: {dest_image_path}") # Copy the caption file(s), if they exist filename_without_ext, _ = os.path.splitext(image.image_file) for ext in caption_extensions: src_caption_path = os.path.join(src_dir, filename_without_ext + ext) if os.path.exists(src_caption_path): dest_caption_path = os.path.join(dest_dir, filename_without_ext + ext) copy_file(src_caption_path, dest_caption_path) print(f"Copied caption: {dest_caption_path}") # Usage in the main section if __name__ == "__main__": # ... (your existing code to load and match images) # Copy matched images to new location copy_to_path = R'D:\AI Generation\Projects\Training\Concept\POV Sex v0.4\img\1_handjob art' for img in matched_images: copy_image_and_caption(img, 'path/to/old/images', copy_to_path)Here's a breakdown of the additional code:
-
copy_file: This helper function handles the actual copying of a file and creates the destination directory if it does not exist. -
copy_image_and_caption: This function takes anImageobject, locates the corresponding image and caption files within the source directory, and copies them to the destination directory. It checks for the existence of any caption files with the provided extensions before attempting to copy them.
In the
copy_image_and_captionfunction, replace'path/to/old/images'with the actual source directory for your images and captions.Make sure that the script has write access to the destination directory and read access to the source directory and files. Running this script should copy the selected images and their captions to the new location, maintaining the original filenames.
-