Azure B2C TrustFrameworkLocalization.xml localization tool

I have TrustFrameworkLocalization.xml file, that contains localized strings, for now only English, but amount of strings is quite big. My colleagues from localization team are not technical people. So, they are not able to modify XML file in the right way. Is there any tool, where they could localize B2C strings and generate TrustFrameworkLocalization.xml file? Something like BabelEdit for JSON?

I asked GPT-4 to write a python script which will for each LocalizedResources Tag in the Policy output an XLSX File that has as it's name the Id of that tag, with the LocalizedString Attributes as columns. It only took 1-2 feedback rounds for it to work. I then took the English example and let people copy the sheet and localize the "Value" columun and give the sheet a name like "fr". Or you just copy & paste the whole Value column into DeepL and it will localize the entire column.

I then asked it to write another script which will read in my excel and output an XML file with XML that looks like it is supposed to and construct a name for each "LocalizedResources" from api + filename + sheetname. I showed it how the XML looks like and it worked after 2 tries. Just had to tell it to remove elements where e.g. the StringId is empty. Then I just copy pasted the whole thing back into the policy.

This is the import script.

import pandas as pd
import os
import xml.etree.ElementTree as ET
from xml.dom import minidom
import argparse
import numpy as np


def prettify(elem):
    """Return a pretty-printed XML string for the Element."""
    rough_string = ET.tostring(elem, 'utf-8')
    reparsed = minidom.parseString(rough_string)
    return reparsed.toprettyxml(indent="  ")


def process_file(file_path):
    # Load the workbook
    workbook = pd.read_excel(file_path, sheet_name=None)

    base_name = os.path.basename(file_path)
    base_name_without_ext = os.path.splitext(base_name)[0]

    # Create root element for combined output
    combined_resources = ET.Element('LocalizedResources')

    # Process each sheet
    for sheet_name, data in workbook.items():
        # Create root element
        resources = ET.Element('LocalizedResources')
        resources.set(
            'Id', f'api.{base_name_without_ext}.{sheet_name.lower()}')

        # Create LocalizedStrings element
        strings = ET.SubElement(resources, 'LocalizedStrings')

        # Process each row
        for i, row in data.iterrows():
            localized_string = ET.SubElement(strings, 'LocalizedString')

            # Add attributes based on row data, convert NaN to ''
            localized_string.set('ElementType', str(
                row['ElementType']) if pd.notna(row['ElementType']) else '')

            if pd.notna(row['ElementId']):
                localized_string.set('ElementId', str(row['ElementId']))

            localized_string.set('StringId', str(
                row['StringId']) if pd.notna(row['StringId']) else '')

            localized_string.text = str(
                row['Value']) if pd.notna(row['Value']) else ''

        # Add processed resources to combined_resources
        combined_resources.append(resources)

    # Write to a single combined XML file
    xml_str = prettify(combined_resources)
    with open(f"{base_name_without_ext}_combined.xml", "w") as f:
        f.write(xml_str)


if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description='Process an XLSX file and generate a combined XML file.')
    parser.add_argument('-f', '--file', required=True,
                        help='Path to the input XLSX file.')
    args = parser.parse_args()
    process_file(args.file)

That's the export script:

import xlsxwriter
import argparse
import xml.etree.ElementTree as ET
import pandas as pd

# Define command line arguments
parser = argparse.ArgumentParser()
parser.add_argument("-f", "--file", help="Path to XML file", )
parser.add_argument("-m", "--mode", help="Mode: Import or Export")
args = parser.parse_args()

print(f"Parsing file: {args.file}")
tree = ET.parse(args.file)
root = tree.getroot()
localized_resources = root.findall(
    ".//{http://schemas.microsoft.com/online/cpim/schemas/2013/06}LocalizedResources")

# Create an new Excel file and add a worksheet.
print("Opening Workbook...")
print(f"Found {len(localized_resources)} localized resources")

writer = pd.ExcelWriter('AzureAD_B2C_Translations.xlsx', engine='xlsxwriter')

for resource in localized_resources:
    resource_id = resource.attrib['Id']
    localized_strings = resource.findall(
        ".//{http://schemas.microsoft.com/online/cpim/schemas/2013/06}LocalizedString")
    print(
        f"Resource {resource.attrib['Id']} has {len(localized_strings)} localized strings...")
    output = []
    for string in localized_strings:
        items = string.items()
        items.append(("Value", string.text))  # type: ignore
        output.append(dict(items))
    df = pd.DataFrame(output)

    df.to_excel(writer, sheet_name=resource_id[4:],
                startrow=0, header=True, index=False)

writer.close()

First I wanted the export script to do both, but I found it easier to just have GPT write two script. Having it write the Import Script literally took 5 minutes with a welll articulated prompt.