Small bits of code, written and explained

Photo Renaming Script

This script renames JPEG images in a specified directory based on their EXIF creation date, ensuring chronological sorting.

Features

• EXIF Date Extraction: Reads the EXIF data of JPEG files to determine the original capture date and time.
• Chronological Renaming: Renames files in the format YYYY-MM-DD_NNN.jpg, where NNN is a sequential counter for each day.
• Error Handling: Gracefully handles files without EXIF data or files that are not JPEGs.
• Safety First: Does not delete original files; renames them in place.

Prerequisites

• Python 3: Ensure you have Python 3 installed on your Mac. You can check this by opening the Terminal and typing python3 --version. If not installed, download it from python.org.
• Pillow Library: This script uses the Pillow library to read EXIF data. Install it using pip:

  pip3 install Pillow
  

Python Script

import os
import sys
from datetime import datetime
from PIL import Image
from PIL.ExifTags import TAGS

def get_creation_date(filepath):
    """
    Retrieves the creation date from a JPEG file's EXIF data.

    Args:
        filepath (str): The full path to the image file.

    Returns:
        datetime or None: A datetime object representing the creation date,
                          or None if EXIF data is not found or unreadable.
    """
    try:
        image = Image.open(filepath)
        exif_data = image._getexif()

        if exif_data is None:
            return None

        # Common EXIF tags for date/time original
        # 36867 is DateTimeOriginal
        # 306 is DateTime
        date_tag = None
        for tag_id, value in exif_data.items():
            tag_name = TAGS.get(tag_id, tag_id)
            if tag_name in ('DateTimeOriginal', 'DateTime'):
                date_tag = value
                break

        if date_tag:
            # EXIF date format is usually 'YYYY:MM:DD HH:MM:SS'
            return datetime.strptime(date_tag, '%Y:%m:%d %H:%M:%S')
    except IOError:
        print(f"Warning: Could not open or read EXIF data for {filepath}. Skipping.")
        return None
    except Exception as e:
        print(f"Warning: An unexpected error occurred while processing EXIF for {filepath}: {e}. Skipping.")
        return None
    return None

def rename_photos_in_directory(directory_path):
    """
    Renames all JPEG photos in a given directory based on their creation date.

    Args:
        directory_path (str): The path to the directory containing the photos.
    """
    if not os.path.isdir(directory_path):
        print(f"Error: Directory '{directory_path}' not found.")
        return

    files = [f for f in os.listdir(directory_path) if os.path.isfile(os.path.join(directory_path, f))]
    # Filter for JPEG files and ensure case-insensitivity for extensions
    jpeg_files = sorted([f for f in files if f.lower().endswith(('.jpg', '.jpeg'))])

    if not jpeg_files:
        print(f"No JPEG files found in '{directory_path}'.")
        return

    date_counts = {}  # To keep track of sequence numbers per day
    renamed_count = 0

    print(f"Processing photos in: {directory_path}")

    for filename in jpeg_files:
        original_filepath = os.path.join(directory_path, filename)
        creation_date = get_creation_date(original_filepath)

        if creation_date:
            date_str = creation_date.strftime('%Y-%m-%d')
            
            # Increment counter for this date
            if date_str not in date_counts:
                date_counts[date_str] = 0
            date_counts[date_str] += 1
            sequence_num = date_counts[date_str]

            # Format the new filename: YYYY-MM-DD_NNN.jpg
            new_filename = f"{date_str}_{sequence_num:03d}.jpg"
            new_filepath = os.path.join(directory_path, new_filename)

            # Avoid renaming if the file is already named correctly or if the new name conflicts
            if filename == new_filename:
                print(f"Skipping already correctly named file: {filename}")
                continue
            if os.path.exists(new_filepath):
                print(f"Warning: Target file '{new_filename}' already exists. Skipping rename for '{filename}'.")
                continue

            try:
                os.rename(original_filepath, new_filepath)
                print(f"Renamed '{filename}' to '{new_filename}'")
                renamed_count += 1
            except OSError as e:
                print(f"Error renaming '{filename}' to '{new_filename}': {e}")
        else:
            print(f"Skipping '{filename}': Could not determine creation date from EXIF.")

    print(f"\nFinished processing. {renamed_count} photos renamed.")

if __name__ == "__main__":
    # IMPORTANT: Replace this with the actual path to your "Italy 2025" folder.
    # For example: "/Users/yourusername/Pictures/Italy 2025"
    # You can drag and drop the folder onto the Terminal window to get its path.
    
    # Example using command-line argument:
    if len(sys.argv) > 1:
        folder_to_process = sys.argv[1]
    else:
        # If no argument is provided, prompt the user or use a default (use with caution)
        # folder_to_process = input("Enter the full path to the photo folder: ")
        # For safety, if no argument is given, it's better to exit and ask for it.
        print("Usage: python rename_photos.py <path_to_your_photo_folder>")
        print("Example: python rename_photos.py /Users/yourusername/Pictures/Italy 2025")
        sys.exit(1)

    rename_photos_in_directory(folder_to_process)

How to Run the Script on a Mac

1. Save the Script:

   • Open a plain text editor (like TextEdit, VS Code, Sublime Text, etc.).
   • Copy the Python code above and paste it into the editor.
   • Save the file with a .py extension, for example, rename_photos.py. Save it in a place you can easily find, like your Documents folder.

2. Open Terminal:

   • Go to your Applications folder, then Utilities, and open Terminal.

3. Navigate to the Script's Directory:

   • In the Terminal, type cd (note the space after cd).
   • Drag and drop the folder where you saved rename_photos.py onto the Terminal window. This will automatically fill in the path.
   • Press Enter.
   • Example: cd /Users/yourusername/Documents

4. Run the Script:

   • To run the script, you need to provide the path to your "Italy 2025" folder as an argument.

   • Type the following command, replacing /path/to/your/Italy 2025 with the actual path to your folder:

     python3 rename_photos.py /path/to/your/Italy 2025
     

   • Tip: You can get the path to your "Italy 2025" folder by opening Finder, navigating to the folder, and then dragging and dropping the "Italy 2025" folder itself onto the Terminal window after you've typed python3 rename_photos.py (with the space).

   • Example: If your photos are in your Pictures folder, your command might look like this:

     python3 rename_photos.py /Users/yourusername/Pictures/Italy\ 2025
     

     (Note the backslash \ before the space in "Italy 2025" if you're typing the path manually. Dragging and dropping usually handles this automatically.)

5. Review the Output:

   • The script will print messages indicating which files are being renamed or if any issues are encountered.
   • Once it finishes, check your "Italy 2025" folder to confirm the renaming.

Important Notes

• Backup First: Although the script is designed not to delete files, it's always a good practice to back up your photos before running any renaming script.
• EXIF Data: The script relies on the EXIF data embedded in your photos. If your photos have had their EXIF data stripped or modified, the script might not be able to determine the original date. In such cases, those files will be skipped and a warning will be printed.
• Case Sensitivity: The script handles file extensions in a case-insensitive manner (.JPG, .jpg, .jpeg, .JPEG).
• File Conflicts: If a file with the target name already exists (e.g., after a previous run or if you have manually created files), the script will skip renaming the current file to avoid overwriting.
• Permissions: Ensure your user account has permission to rename files in the target directory.

Debugging SUMIFS Formula for Household Budget

The provided SUMIFS formula contains several issues that prevent it from correctly calculating the total spent on "Groceries" in March 2026.

Root Cause Analysis

1. Category String Literal: The Groceries criterion in SUMIFS(C:C, B:B, Groceries, ...) is treated as a cell reference rather than a text string. Without quotes, Google Sheets interprets Groceries as a cell containing the value to match, which is likely not intended.
2. Date Format Ambiguity: The date criteria ">=1/3/2026" and "<31/3/2026" use a day/month/year format. While Google Sheets can sometimes interpret this, it's highly dependent on regional settings and can lead to unexpected behavior or errors if the settings don't match. The standard and most robust way to specify dates in formulas is using the DATE function or a consistent year-month-day format.
3. Inclusive End Date: The end date criterion "<31/3/2026" is inclusive for the day. However, when comparing dates, it's often safer and more common to use < with the start of the next period to ensure all values within the target month are captured, especially if times are involved (though less critical in this specific sheet context, it's good practice).

Corrected Formula

The corrected formula addresses these issues by:

• Enclosing the category name in double quotes.
• Using the DATE function for unambiguous date comparisons, ensuring correct handling of the month and year regardless of regional settings.
• Using < with the first day of the next month to ensure all days of March are included.

=SUMIFS(C:C, B:B, "Groceries", A:A, ">=2026-03-01", A:A, "<2026-04-01")

Alternatively, using the DATE function for maximum clarity and robustness:

=SUMIFS(C:C, B:B, "Groceries", A:A, ">="&DATE(2026, 3, 1), A:A, "<"&DATE(2026, 4, 1))

Explanation of Corrections

• "Groceries": The category name is now correctly enclosed in double quotes, treating it as a literal string.
• ">=2026-03-01" and "<2026-04-01": These use the unambiguous YYYY-MM-DD format, which Google Sheets reliably interprets as dates. The first condition includes all dates on or after March 1, 2026. The second condition includes all dates strictly before April 1, 2026, effectively capturing all of March.
• ">="&DATE(2026, 3, 1) and "<"&DATE(2026, 4, 1): This approach uses the DATE(year, month, day) function to construct the dates programmatically. This is the most robust method as it completely bypasses any regional settings interpretation for dates. The & operator concatenates the comparison operator (>= or <) with the date value.

Debugging Report: Expense Calculator

Root Cause Analysis

The script fails because it attempts to add strings to a numeric type (int or float). The expenses list contains expense values as strings (e.g., "45.20"). When the loop iterates, it tries to perform string concatenation (0 + "45.20") which results in a string "45.20". In subsequent iterations, it continues concatenating strings, leading to an unexpected string output rather than a numerical sum.

Corrected Code

expenses = ["45.20", "12.99", "80.00", "7.50"]
total = 0.0  # Initialize total as a float to handle decimal values
for e in expenses:
    try:
        # Convert each expense string to a float before adding
        total += float(e)
    except ValueError:
        # Handle cases where an item in the expenses list is not a valid number
        print(f"Warning: Skipping invalid expense entry: {e}")

print(f"Total spent: {total:.2f}")

Explanation of Fixes

1. Type Conversion: The core issue was the type mismatch. Each string element e from the expenses list is now explicitly converted to a float using float(e) before being added to the total.
2. Initialization: The total variable is initialized to 0.0 (a float) instead of 0 (an integer). This ensures that the total variable is of a type that can accommodate decimal values from the start, preventing potential precision loss if intermediate calculations were to occur without it.
3. Error Handling: A try-except block is added to gracefully handle ValueError. This occurs if any item in the expenses list cannot be converted to a float (e.g., if it were accidentally None or contained non-numeric characters). This makes the script more robust.
4. Formatted Output: The final print statement uses an f-string with :.2f formatting to display the total spending rounded to two decimal places, which is standard for currency.