Replacing First Hyphen in a Folder Name but Leave Any Other Hyphens Unchanged?

[tatihulot]

Hello and Happy New Year.
May I please explain what I need to do. I have a folder named C:\MUSIC2025 that contains my entire music collection.
The folder contains over 5,000 subfolders.
I need to rename the folders, so the first hyphen in the folder name is replaced with an equal sign.
However, I do not want any other hyphens that may be in the folder name to be replaced.
Please take a look at the example below.


Before:
38 Special - Strength In Numbers
38 Special - The Very Best Of The A&M Years (1977-1988)
38 Special - Tour De Force
38 Special - Wild-Eyed Southern Boys
1910 Fruitgum Company - 1968-1970
ABBA - Complete Studio Recordings
ACDC - Back in Black

After:
38 Special = Strength In Numbers
38 Special = Very Best Of The A&M Years (1977-1988)
38 Special = Tour De Force
38 Special = Wild-Eyed Southern Boys
1910 Fruitgum Company = 1968-1970
ABBA = Complete Studio Recordings
ACDC = Back in Black

I’m not really a programmer, so I had ChatGPT generate some code. I haven’t tried it yet, so I don’t know if it works. I figured I’d ask Python experts to take a look at it and see if it will do what I want. So, if anyone is willing to examine it and see if it will work, I’d really greatly appreciate this.

import os

def replace_first_hyphen_with_equals(directory):
    try:
        # Get a list of all items in the directory
        items = os.listdir(directory)
        
        for item in items:
            # Get the full path of the item
            item_path = os.path.join(directory, item)
            
            # Check if the item is a directory
            if os.path.isdir(item_path):
                # Replace the first hyphen with an equal sign
                new_name = item.replace("-", "=", 1)
                
                # Rename the folder
                if new_name != item:  # Avoid renaming if no change is made
                    new_path = os.path.join(directory, new_name)
                    os.rename(item_path, new_path)
                    print(f"Renamed: {item} -> {new_name}")
                else:
                    print(f"No hyphen found in: {item}")
    except Exception as e:
        print(f"An error occurred: {e}")

# Example usage
directory_path = "/path/to/your/directory"
replace_first_hyphen_with_equals(directory_path)

If anyone has any suggestions to do this a different way, I’m receptive.
Thank you very much! Jd

(PS: If I may, let me tell you why I’m doing this. After the folders are renamed, I will generate a CSV file, using a file and folder list creator. Then, I will import it into an Excel spreadsheet via Power Query, using the Equal sign as the delimiter. I want only two columns in the spreadsheet; one for Artist, one for Title. As the folder names exist now, when I do this, I get several columns. No way am I going to edit the data manually. I hope this makes a little sense.)

Gribouillis write Dec-31-2024, 04:56 PM:
Please post all code, output and errors (it it's entirety) between their respective tags. Refer to BBCode help topic on how to post. Use the "Preview Post" button to make sure the code is presented as you expect before hitting the "Post Reply/Thread" button.

[Gribouillis]

Here is an improved version. The main changes are

• I added code so that you can run the script in a terminal like "python program.py /path/to/directory"
  
• I replaced the first hyphen OR equal sign by an equal sign, so that if you run the code more than once on the same directory it won't replace the second hyphen by an equal sign.
  

from argparse import ArgumentParser
import os
import re

def replace_first_hyphen_with_equals(directory):
    # Get a list of all items in the directory
    _, subdirs, _ = next(os.walk(directory))

    for item in subdirs:
        # Replace the first hyphen or equal sign with an equal sign
        new_name = re.sub(r'[=-]', '=', item, count=1)

        # Rename the folder
        if new_name != item: # Avoid renaming if no change is made
            item_path = os.path.join(directory, item)
            new_path = os.path.join(directory, new_name)
            try:
                os.rename(item_path, new_path)
            except Exception as e:
                print(f"An error occurred: {e}")
            else:
                print(f"Renamed: {item} -> {new_name}")
        else:
            print(f"Nothing to rename for: {item}")


# Example usage
# directory_path = "/path/to/your/directory"
# replace_first_hyphen_with_equals(directory_path)

if __name__ == '__main__':
    parser = ArgumentParser(
        description='Rename subdirectories by replacing hyphen with equal sign')
    parser.add_argument(directory)
    ns = parser.parse_args()
    replace_first_hyphen_with_equals(ns.directory)

Note: There will be error reports if a target already exists. For example when renaming Spam - Eggs to Spam = Eggs, the program will refuse to rename if a file or a subdirectory named Spam = Eggs already exists. Other possible source of error reports is if you don't have the required file permissions to do the renaming.

[tatihulot]

Hello.

Thank you for replying and helping me. Please keep in mind I'm not a programmer and am not 100% sure I'm doing things properly.

I installed Python and VS Code on my computer. In Python I pasted your code in and saved it as a .PY file.

I then opened the file in VS code and tried running it.

I got this message:

SyntaxError: leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers

Did I do anything wrong? Thank you.

[Gribouillis]

I then opened the file in VS code and tried running it.

I got this message:

SyntaxError: leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers

I don't use VS code and I don't know how you tried to run the program, so I can't tell you what's going on.
There is no integer literal with a leading zero in my code, so the error cannot come from this code.

Try to run the program from the integrated terminal that comes in VS code. The program is meant to be run in a terminal by typing a command such as

Output:
python PATHTOPYFILE PATHTOFOLDER

[DeaD_EyE]

Example with pathlib.Path.
The Path object is an abstraction of paths and if understood, it's easier to handle Paths.

What you cannot do is renaming non-empty directories with Path.rename(). I don't know if os.rename does the same, but instead I use shutil.move to rename directories.

import os
import re
import shutil
from operator import itemgetter
from pathlib import Path


def make_testdirs(path: str, subdirs: bool) -> None:
    """
    Create test directories
    """
    root = Path(path)

    names = (
        "38 Special - Strength In Numbers",
        "38 Special - The Very Best Of The A&M Years (1977-1988)",
        "38 Special - Tour De Force",
        "38 Special - Wild-Eyed Southern Boys",
        "1910 Fruitgum Company - 1968-1970",
        "ABBA - Complete Studio Recordings",
        "ACDC - Back in Black",
    )
    for name in names:
        (root / name).mkdir(parents=True, exist_ok=True)
        if subdirs:
            for name in names:
                (root / name / name).mkdir(parents=True, exist_ok=True)


def to_target(path: Path | str) -> Path:
    path = Path(path)
    # without regex
    # name = path.name.replace(" - ", " = ", count=1)
    # with regex
    name = re.sub(r" - ", " = ", path.name, count=1)
    return Path(path.parent, name)


def rename(root: Path | str) -> None:
    """
    Walking recursive from root path and moving the deepest directories first.
    """
    root = Path(root)
    root_depth = len(root.parts)

    # adding TypeHints to help the IDE to know the
    # expected types
    dirs_to_rename: list[tuple[Path, Path, int]] = []

    # If you're not using Python 3.13+, then the Path.walk() does not
    # exist. Then use os.walk(path, topdown=False) instead.
    #
    # for top, dirs, files in os.walk(root, topdown=False):
    #     top = Path(top) # top is not a Path object, so converting it
    for top, dirs, files in root.walk(top_down=False):
        # only interested in directories
        for directory in dirs:
            # you can use the / to join Path objects
            # the result is a new Path object
            source = top / directory
            source_depth = len(source.parts) - root_depth
            # := is a named assignment (walrus operator)
            # source if compared of equalness to target, where
            # target is the return value from to_target(source)
            if source != (target := to_target(source)):
                dirs_to_rename.append((source, target, source_depth))

    print(f"Renaming {len(dirs_to_rename)} directories")

    # This is not required, if root.walk(top_down=False) or os.walk(root, topdown=False)
    # were used. Then the depth directories walked first.
    # - sorting the found directories by depth inplace (2nd element)
    # - the biggest depth first to smalles depth (reverse=True)
    # dirs_to_rename.sort(key=itemgetter(2), reverse=True)

    for source, target, level in dirs_to_rename:
        try:
            # trying to move the directory,
            # renaming doesn't work if the directory is not empty
            shutil.move(source, target)
            print(f"[{level:^4d}] {source} => {target}")
        except Exception as e:
            print("Exception:", e)

    # returning the result for later use maybe
    return dirs_to_rename


SCRIPT_TEST = Path("SCRIPT_TEST")
if not SCRIPT_TEST.exists():
    make_testdirs(SCRIPT_TEST, True)

result = rename(SCRIPT_TEST)

Shorter version without re, helper function and comments:

import shutil
from pathlib import Path


def to_target(path: Path | str) -> Path:
    path = Path(path)
    name = path.name.replace(" - ", " = ", count=1)
    return Path(path.parent, name)


def rename(root: Path | str) -> None:
    """
    Walking recursive from root path and moving the deepest directories first.
    """
    root = Path(root)
    root_depth = len(root.parts)

    for top, dirs, files in root.walk(top_down=False):
        for directory in dirs:
            source = top / directory
            source_depth = len(source.parts) - root_depth
            if source != (target := to_target(source)):
                try:
                    shutil.move(source, target)
                    print(f"[{source_depth:^4d}] {source} => {target}")
                except Exception as e:
                    print("Exception:", e)


rename("SCRIPT_TEST")