Versioned File Naming Function

2024-02-06 17:55 UTC gpt-4 Open in ChatGPT ↗

To add a versioning function to a file-naming system, we can create a simple script that checks if a file with the proposed name already exists. If it does, the script will increment the version number until it finds a name that is not already in use. This approach ensures that each new file has a unique name, with a version suffix that increases numerically.

Here’s a basic example of how such a function could look in Python. This function assumes that you’re working with plain text files, but you can modify the extension as needed:

import os

def get_versioned_filename(base_name, directory, extension='.txt'):
    version = 1
    # Format the initial filename
    filename = f"{base_name}_V{version}{extension}"
    # Construct the full path to check if it exists
    full_path = os.path.join(directory, filename)

    # Loop until a unique filename is found
    while os.path.exists(full_path):
        version += 1  # Increment the version
        filename = f"{base_name}_V{version}{extension}"  # Update the filename with the new version
        full_path = os.path.join(directory, filename)  # Update the full path

    return filename  # Return the unique filename

# Example usage
base_name = "XXXXXXX"
directory = "/path/to/directory"  # Replace with the actual directory path
versioned_filename = get_versioned_filename(base_name, directory)
print(versioned_filename)

This function takes a base name for the file (base_name), the directory where the file will be saved (directory), and an optional file extension (extension, defaulting to .txt). It constructs a filename using the base name and a version number, then checks if a file with that name already exists in the specified directory. If the file exists, it increments the version number and checks again, repeating this process until it finds a unique filename. Finally, it returns the unique filename.

To use this function, replace "/path/to/directory" with the actual path where your files are stored, and call the function with the desired base name for your file. The function will print the versioned filename that does not conflict with existing files in the directory.

Make it work with this:

import c4d

def write_frame_data(filePath, frame_data): with open(filePath, “a”) as file: # Join all red values into a single line line = ”,“.join(frame_data) file.write(line + “\n”)

def main(): # Get the active Cinema 4D document doc = c4d.documents.GetActiveDocument()

# Find the Matrix object by name 'Export'
matrix_object = doc.SearchObject('Export')

# Check if the Matrix object is correctly referenced
if not matrix_object:
    print("Matrix object named 'Export' not found")
    return

# Get the grid resolution vector
grid_resolution = matrix_object[c4d.MG_GRID_RESOLUTION]
if grid_resolution is None:
    print("Grid resolution data not found")
    return

# Extract the X and Z values (assuming your grid is in the XZ plane)
x_grid_size = int(grid_resolution.x)
z_grid_size = int(grid_resolution.z)

# Determine the range of frames to iterate over
startFrame = doc.GetLoopMinTime().GetFrame(doc.GetFps())
endFrame = doc.GetLoopMaxTime().GetFrame(doc.GetFps())
numberOfFrames = endFrame - startFrame + 1

# Amend the file path with the number of frames and grid sizes
filePath = f"H:/My Drive/02_Projects/41_SPTF_FCBNY Spotify/01_Production/C4D/240205_WriteValuesToExcel/Written/single_channel_values_{numberOfFrames}_frames_{x_grid_size}x{z_grid_size}grid.csv"

# Iterate over each frame in the range
for frame in range(startFrame, endFrame + 1):
    # Set the document's time to the current frame
    doc.SetTime(c4d.BaseTime(frame, doc.GetFps()))

    # Update the document to reflect the change in time
    c4d.DrawViews(c4d.DA_ONLY_ACTIVE_VIEW | c4d.DA_NO_THREAD | c4d.DA_STATICBREAK)
    c4d.GeSyncMessage(c4d.EVMSG_TIMECHANGED)
    doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_0)

    # Accessing MoGraph Data
    md = c4d.modules.mograph.GeGetMoData(matrix_object)
    if md is None:
        print("MoGraph data not found for frame", frame)
        continue

    # Get the array of colors of the clones for the current frame
    colors = md.GetArray(c4d.MODATA_COLOR)
    if colors is None:
        print("Color data not found for frame", frame)
        continue

    # Convert color values to 0-255 range and format them for CSV, but only include the red component, ensuring values are clamped between 0 and 255
    frame_data = [f"{max(0, min(int(color.x*255), 255))}" for color in colors]

    # Write the current frame's red color data to the file
    write_frame_data(filePath, frame_data)

# Print a message for confirmation
print(f"Red color data for frames {startFrame} to {endFrame} written to file")

Execute the main function

if name==‘main’: main()

To incorporate versioning into the given script, you can modify the part where filePath is set. Before setting the final filePath, you should check if a file with the intended name already exists, and if so, increment a version number until a unique file name is found. Below is a modified version of your script with a function get_versioned_filename that handles the versioning:

import c4d
import os

def get_versioned_filename(base_name, directory, extension='.csv'):
    version = 1
    # Format the initial filename
    filename = f"{base_name}_V{version}{extension}"
    # Construct the full path to check if it exists
    full_path = os.path.join(directory, filename)

    # Loop until a unique filename is found
    while os.path.exists(full_path):
        version += 1  # Increment the version
        filename = f"{base_name}_V{version}{extension}"  # Update the filename with the new version
        full_path = os.path.join(directory, filename)  # Update the full path

    return full_path  # Return the unique file path with version

def write_frame_data(filePath, frame_data):
    with open(filePath, "a") as file:
        # Join all red values into a single line
        line = ",".join(frame_data)
        file.write(line + "\n")

def main():
    # Get the active Cinema 4D document
    doc = c4d.documents.GetActiveDocument()

    # Find the Matrix object by name 'Export'
    matrix_object = doc.SearchObject('Export')
    if not matrix_object:
        print("Matrix object named 'Export' not found")
        return

    # Get the grid resolution vector
    grid_resolution = matrix_object[c4d.MG_GRID_RESOLUTION]
    if grid_resolution is None:
        print("Grid resolution data not found")
        return

    x_grid_size = int(grid_resolution.x)
    z_grid_size = int(grid_resolution.z)

    startFrame = doc.GetLoopMinTime().GetFrame(doc.GetFps())
    endFrame = doc.GetLoopMaxTime().GetFrame(doc.GetFps())
    numberOfFrames = endFrame - startFrame + 1

    base_directory = "H:/My Drive/02_Projects/41_SPTF_FCBNY Spotify/01_Production/C4D/240205_WriteValuesToExcel/Written"
    base_name = f"single_channel_values_{numberOfFrames}_frames_{x_grid_size}x{z_grid_size}grid"

    # Use versioning function to get a unique file path
    filePath = get_versioned_filename(base_name, base_directory)

    for frame in range(startFrame, endFrame + 1):
        doc.SetTime(c4d.BaseTime(frame, doc.GetFps()))
        c4d.DrawViews(c4d.DA_ONLY_ACTIVE_VIEW | c4d.DA_NO_THREAD | c4d.DA_STATICBREAK)
        c4d.GeSyncMessage(c4d.EVMSG_TIMECHANGED)
        doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_0)

        md = c4d.modules.mograph.GeGetMoData(matrix_object)
        if md is None:
            print(f"MoGraph data not found for frame {frame}")
            continue

        colors = md.GetArray(c4d.MODATA_COLOR)
        if colors is None:
            print(f"Color data not found for frame {frame}")
            continue

        frame_data = [f"{max(0, min(int(color.x*255), 255))}" for color in colors]
        write_frame_data(filePath, frame_data)

    print(f"Red color data for frames {startFrame} to {endFrame} written to file {filePath}")

if __name__=='__main__':
    main()

In this version, the get_versioned_filename function is defined at the beginning of the script. It constructs the file name with a version number and checks if it exists in the specified directory. If the file exists, it increments the version number until it finds a unique name. The filePath is then set using this function, ensuring that each time the script is run, it will generate a new file if the previous one already exists, preventing overwriting of data.

Add the same versioning functionality to this:

import c4d

def write_frame_data(filePath, frame_data): with open(filePath, “a”) as file: # Join all RGB values into a single line line = ”,“.join(frame_data) file.write(line + “\n”)

def main(): # Get the active Cinema 4D document doc = c4d.documents.GetActiveDocument()

# Find the Matrix object by name 'Export'
matrix_object = doc.SearchObject('Export')

# Check if the Matrix object is correctly referenced
if not matrix_object:
    print("Matrix object named 'Export' not found")
    return

# Get the grid resolution vector
grid_resolution = matrix_object[c4d.MG_GRID_RESOLUTION]
if grid_resolution is None:
    print("Grid resolution data not found")
    return

# Extract the X and Y values (assuming Y is the second dimension in your grid)
x_grid_size = int(grid_resolution.x)
z_grid_size = int(grid_resolution.z)  # Or z if your grid is in the XZ plane

# Determine the range of frames to iterate over
startFrame = doc.GetLoopMinTime().GetFrame(doc.GetFps())
endFrame = doc.GetLoopMaxTime().GetFrame(doc.GetFps())
numberOfFrames = endFrame - startFrame + 1

# Amend the file path with the number of frames and grid sizes
filePath = f"H:/My Drive/02_Projects/41_SPTF_FCBNY Spotify/01_Production/C4D/240205_WriteValuesToExcel/Written/matrix_colors_{numberOfFrames}_frames_{x_grid_size}x{z_grid_size}grid.csv"

# Iterate over each frame in the range
for frame in range(startFrame, endFrame + 1):
    # Set the document's time to the current frame
    doc.SetTime(c4d.BaseTime(frame, doc.GetFps()))

    # Update the document to reflect the change in time
    c4d.DrawViews(c4d.DA_ONLY_ACTIVE_VIEW | c4d.DA_NO_THREAD | c4d.DA_STATICBREAK)
    c4d.GeSyncMessage(c4d.EVMSG_TIMECHANGED)
    doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_0)

    # Accessing MoGraph Data
    md = c4d.modules.mograph.GeGetMoData(matrix_object)
    if md is None:
        print("MoGraph data not found for frame", frame)
        continue

    # Get the array of colors of the clones for the current frame
    colors = md.GetArray(c4d.MODATA_COLOR)
    if colors is None:
        print("Color data not found for frame", frame)
        continue

    # Convert color values to 0-255 range and format them for CSV
    frame_data = [f"{int(color.x*255)}, {int(color.y*255)}, {int(color.z*255)}" for color in colors]

    # Write the current frame's color data to the file
    write_frame_data(filePath, frame_data)

# Print a message for confirmation
print(f"Color data for frames {startFrame} to {endFrame} written to file")

Execute the main function

if name==‘main’: main()

To add the same versioning functionality to the script that writes frame data for colors, you can modify it similarly by incorporating a function to handle file versioning. This function will ensure that each time the script runs, it generates a new file with an incremented version number if a file with the intended name already exists.

Here’s how you can integrate the versioning functionality into your script:

import c4d
import os

def get_versioned_filename(base_name, directory, extension='.csv'):
    version = 1
    filename = f"{base_name}_V{version}{extension}"
    full_path = os.path.join(directory, filename)

    while os.path.exists(full_path):
        version += 1
        filename = f"{base_name}_V{version}{extension}"
        full_path = os.path.join(directory, filename)

    return full_path

def write_frame_data(filePath, frame_data):
    with open(filePath, "a") as file:
        line = ",".join(frame_data)
        file.write(line + "\n")

def main():
    doc = c4d.documents.GetActiveDocument()
    matrix_object = doc.SearchObject('Export')
    if not matrix_object:
        print("Matrix object named 'Export' not found")
        return

    grid_resolution = matrix_object[c4d.MG_GRID_RESOLUTION]
    if grid_resolution is None:
        print("Grid resolution data not found")
        return

    x_grid_size = int(grid_resolution.x)
    z_grid_size = int(grid_resolution.z)

    startFrame = doc.GetLoopMinTime().GetFrame(doc.GetFps())
    endFrame = doc.GetLoopMaxTime().GetFrame(doc.GetFps())
    numberOfFrames = endFrame - startFrame + 1

    base_directory = "H:/My Drive/02_Projects/41_SPTF_FCBNY Spotify/01_Production/C4D/240205_WriteValuesToExcel/Written"
    base_name = f"matrix_colors_{numberOfFrames}_frames_{x_grid_size}x{z_grid_size}grid"

    filePath = get_versioned_filename(base_name, base_directory)

    for frame in range(startFrame, endFrame + 1):
        doc.SetTime(c4d.BaseTime(frame, doc.GetFps()))
        c4d.DrawViews(c4d.DA_ONLY_ACTIVE_VIEW | c4d.DA_NO_THREAD | c4d.DA_STATICBREAK)
        c4d.GeSyncMessage(c4d.EVMSG_TIMECHANGED)
        doc.ExecutePasses(None, True, True, True, c4d.BUILDFLAGS_0)

        md = c4d.modules.mograph.GeGetMoData(matrix_object)
        if md is None:
            print(f"MoGraph data not found for frame {frame}")
            continue

        colors = md.GetArray(c4d.MODATA_COLOR)
        if colors is None:
            print(f"Color data not found for frame {frame}")
            continue

        frame_data = [f"{int(color.x*255)}, {int(color.y*255)}, {int(color.z*255)}" for color in colors]
        write_frame_data(filePath, frame_data)

    print(f"Color data for frames {startFrame} to {endFrame} written to file {filePath}")

if __name__=='__main__':
    main()

This modified script includes the get_versioned_filename function, which generates a unique file path by checking for existing files and incrementing a version number as needed. The filePath is then determined using this function, ensuring that new data is always written to a new file, preserving the integrity of existing data.