Odoo does not provide any "easy or standard" way of doing this.

I would do a "server action" 

Give the action a list of Attribute 'VALUES' to be merged. And a variable containing the "new" Attribute 'VALUE'.

Then go over product.product and check if ANY of the attribute values correspond with the ones on your list.

And if so, then Add the new value to the product.product, and remove the old ones from that product.product.

Also you should take into account the stock.moves, quants, etc of the duplicated product.product

So the final result should be just one product.product variant.

I used AI to generate a code that could make this

!!!WARNING!!!: i have not tested this code, please use it as reference, and test it un demo database before trying in production.

The goal is to merge redundant attribute values (such as "Large," "LARGE," etc.) into one unified value under the same product attribute in Odoo 17. This needs to be done efficiently across all products and their variants without disrupting stock or creating new variants manually.

Problem Breakdown:

Redundant Attribute Values: You have multiple variants of the "Size" attribute that all represent the same meaning (e.g., "Large", "LARGE", etc.).

Merging Requirement: The goal is to identify products with these redundant values, replace them with a unified value, and delete or archive the old ones.

Current Constraints:

Odoo does not have a standard feature to merge attribute values.

Manually updating variants and stock would be time-consuming.

Steps to Solve the Problem:

Server Action: Using a server action can automate this process.

The server action will:

Take a list of old values (e.g., "Large", "LARGE", etc.).

Identify products/variants that use these values.

Replace the old values with a unified one (e.g., "Large").

Archive or delete the old values.

Considerations:

Stock Handling: Odoo tracks stock per product variant. When changing attribute values, Odoo could potentially treat it as a new product variant. Therefore, ensuring the stock is carried over correctly is crucial.

Product Variants: Product variants with these attribute values must be updated without creating new ones, as this would lead to stock management issues.

Data Integrity: Care must be taken to ensure that relationships between products, attributes, and stock are preserved.

Alternative Approach:

Instead of merging in bulk, manually adjusting stock might be the safest route, but this is not feasible for a large volume of data. A custom migration script or server action is the most efficient way, as Odoo doesn't offer this feature natively.

Final Approach:

Loop through the product.product model to identify products with the redundant attribute values.

Replace these values with the unified value.

Ensure that the product variant remains the same, avoiding new variant creation.

Archive the old attribute values after the process.

Explanation:

The script begins by locating the attribute ("Size") and the relevant attribute values that need to be merged.

It loops through the products (product.product) that contain the old attribute values and updates them with the new unified value.

After updating the products, it archives the old values so they are no longer in use but can be referred back to if needed.

The function is parameterized so it can be reused for other attributes as well.

The request to merge redundant attribute values while ensuring that only one product.product remains requires a deeper reflection on Odoo's stock and order management systems. Changing or merging product attributes can affect various models such as stock.move, stock.move.line, stock.quant, sale.order.line, purchase.order.line, and possibly mrp.production (if manufacturing is involved). Handling these relations properly will ensure that no stock discrepancies, broken references, or invalid product variants occur.

Problem Breakdown:

Primary Objective: Merge attribute values so that only one product.product variant remains, without creating new variants.

Stocks and Orders: Odoo tracks product movements through multiple models such as stock.quant (for current stock quantities), stock.move (for ongoing product movements), sale.order.line (for product sales), purchase.order.line (for product purchases), etc. Any product with stock or movement cannot simply be deleted without proper handling.

Possible Issues:

Deleting a product.product that has stock or is linked to any ongoing orders could result in data integrity issues.

Orders, deliveries, and manufacturing processes might still reference old variants, leading to broken references if not handled carefully.

Goal: Transfer all relevant data from old product variants (with redundant attribute values) to a unified product variant, updating references and consolidating stock, before safely removing redundant variants.

Steps to Address the Problem:

Stock Consolidation: Ensure all stock for old variants is transferred to the new product variant.

Check and update stock.quant for current stock levels.

Update stock.move and stock.move.line for ongoing stock transfers or deliveries.

Order and Transaction Handling:

Update sale.order.line, purchase.order.line, and any other transaction records that reference the old product variants to point to the new one.

Data Integrity: Ensure that no dangling references to the old product variants remain in any models after the merge.

Archive Old Variants: After successfully transferring stock and updating all references, old product variants should be archived, but not deleted, for traceability.

Considerations:

Stock Levels: Ensure that stock is accurately transferred. Use the stock.quant model for this.

Ongoing Orders: Any ongoing orders or transfers should be properly adjusted by updating their product_id to the new variant.

Atomic Operation: The process should be done in an atomic way to prevent issues if the process is interrupted.

Alternative Approaches:

One alternative approach could be to handle this manually via export/import tools or scripts outside of Odoo, but this would still be inefficient and prone to errors. A properly scripted server action or module is the most efficient solution given the complexity and scale of the task.

Final Approach:

The script should:

• Identify all models that reference the product.product variants (including stock and orders).
• Update all these references to the new product variant.
• Transfer stock from old variants to the new one.
• Archive the old variants to avoid conflicts.
• 
  

# python code

def merge_product_variants(attribute_name, old_values, new_value):

    # Get the attribute by name

    attribute = env['product.attribute'].search([('name', '=', attribute_name)], limit=1)

    if not attribute:

        raise ValueError(f"Attribute '{attribute_name}' not found.")

    # Get the new unified attribute value

    new_attribute_value = env['product.attribute.value'].search([('attribute_id', '=', attribute.id), ('name', '=', new_value)], limit=1)

    if not new_attribute_value:

        raise ValueError(f"New Attribute Value '{new_value}' not found.")

    # Get old attribute values to be merged

    old_attribute_values = env['product.attribute.value'].search([('attribute_id', '=', attribute.id), ('name', 'in', old_values)])

    if not old_attribute_values:

        raise ValueError(f"No old attribute values found for {old_values}.")

    # Find all products using old attribute values

    old_products = env['product.product'].search([('attribute_value_ids', 'in', old_attribute_values.ids)])

    # Find or create the new product variant that should remain

    new_product = env['product.product'].search([('attribute_value_ids', 'in', new_attribute_value.ids)], limit=1)

    if not new_product:

        raise ValueError(f"Product with the new value '{new_value}' not found.")

    # Migrate stock from old products to the new one

    for old_product in old_products:

        if old_product != new_product:

            # Transfer stock.quants

            quants = env['stock.quant'].search([('product_id', '=', old_product.id)])

            for quant in quants:

                quant.sudo().write({'product_id': new_product.id})

            # Transfer stock.move.lines

            move_lines = env['stock.move.line'].search([('product_id', '=', old_product.id)])

            for line in move_lines:

                line.sudo().write({'product_id': new_product.id})

            # Transfer stock.moves

            moves = env['stock.move'].search([('product_id', '=', old_product.id)])

            for move in moves:

                move.sudo().write({'product_id': new_product.id})

            # Transfer ongoing orders (sale.order.line, purchase.order.line)

            sale_order_lines = env['sale.order.line'].search([('product_id', '=', old_product.id)])

            for sol in sale_order_lines:

                sol.sudo().write({'product_id': new_product.id})

            purchase_order_lines = env['purchase.order.line'].search([('product_id', '=', old_product.id)])

            for pol in purchase_order_lines:

                pol.sudo().write({'product_id': new_product.id})

            # Archive the old product variant

            old_product.sudo().write({'active': False})

    return f"Successfully merged products with values {old_values} into '{new_value}', stock and orders transferred."

# Parameters for merging

merge_product_variants(

    attribute_name='Size',  # The attribute name

    old_values=['Large', 'LARGE', 'LArge1', 'L'],  # Old attribute values

    new_value='Large'  # New unified value

)

Explanation:

Finding the Products: The script first searches for the old product variants that need to be merged.

Stock Transfer: It loops through stock.quant, stock.move, and stock.move.line records related to each old product and updates them to point to the new product.

Order Transfer: It handles ongoing orders by updating sale.order.line and purchase.order.line records to point to the new product.

Archiving Old Variants: After stock and orders are transferred, the old products are archived to ensure only one product remains active.

This method ensures that stock, orders, and all relevant transactions are updated seamlessly to reflect the unified product, preventing any disruptions in stock management or orders.

i think it's posible with Large, LARGE, LArge1,
but if L or L4rg3, it's not posible

you can use python .find() to do that, but you of to make lowercase first using .lower()