Python: apply wildcard match to keys being read from dictionary

Question

This is for a script I'm running in Blender, but the question pertains to the Python part of it. It's not specific to Blender.

The script is originally from this answer, and it replaces a given material (the key) with its newer equivalent (the value).

Here's the code:

import bpy

objects = bpy.context.selected_objects

mat_dict =  {
  "SOLID-WHITE": "Sld_WHITE",
  "SOLID-BLACK": "Sld_BLACK",
  "SOLID-BLUE": "Sld_BLUE"
}

for obj in objects:
    for slot in obj.material_slots:
        slot.material = bpy.data.materials[mat_dict[slot.material.name]]

The snag is, how to handle duplicates when the scene may have not only objects with the material "SOLID-WHITE", but also "SOLID-WHITE.001", "SOLID-WHITE.002", and so on.

I was looking at this answer to a question about wildcards in Python and it seems fnmatch might well well-suited for this task.

I've tried working fnmatch into the last line of the code. I've also tried wrapping the dictionary keys with it (very WET, I know). Neither of these approaches has worked.

How can I run a wildcard match on each dictionary key?

So for example, whether an object has "SOLID-WHITE" or "SOLID-WHITE"-dot-some-number, it will still be replaced with "Sld_WHITE"?

Answer 1

There are two ways you can approach this. You can make a smart dictionary that matches vague names. Or you can change the key that is used to look up the a color.

Here is an example of the first approach using fnmatch. this approach changes the lookup time complexity from O(1) to O(n) when a color contains a number. this approach extends UserDict with a __missing__ method. the __missing__ method gets called if the key is not found in the dictionary. it compares every key with the given key using fnmatch.

from collections import UserDict
import fnmatch
import bpy

objects = bpy.context.selected_objects

class Colors(UserDict):
    def __missing__(self, key):
        for color in self.keys():
            if fnmatch.fnmatch(key, color + "*"):
                return self[color]
        raise KeyError(f"could not match {key}")

mat_dict = Colors({
  "SOLID-WHITE": "Sld_WHITE",
  "SOLID-BLACK": "Sld_BLACK",
  "SOLID-BLUE": "Sld_BLUE"
})

for obj in objects:
    for slot in obj.material_slots:
        slot.material = bpy.data.materials[mat_dict[slot.material.name]]

Here is an example of the second approach using regex.

import re
import bpy

objects = bpy.context.selected_objects

mat_dict =  {
  "SOLID-WHITE": "Sld_WHITE",
  "SOLID-BLACK": "Sld_BLACK",
  "SOLID-BLUE": "Sld_BLUE"
}

pattern = re.compile(r"([A-Z\-]+)(?:\.\d+)?")
# matches any number of capital letters and dashes
# can be followed by a dot followed by any number of digits
# this pattern can match the following strings
# ["AAAAA", "----", "AA-AA.00005"]


for obj in objects:
    for slot in obj.material_slots:
        match = pattern.fullmatch(slot.material.name)
        if match:
            slot.material = bpy.data.materials[mat_dict[match.group(1)]]
        else:
            slot.material = bpy.data.materials[mat_dict[slot.material.name]]

Answer 2

I have no clue about Blender so I'm not sure if I'm getting the problem right, but how about the following?

mat_dict =  {
  "SOLID-WHITE": "Sld_WHITE",
  "SOLID-BLACK": "Sld_BLACK",
  "SOLID-BLUE": "Sld_BLUE"
}

def get_new_material(old_material):
    for k, v in mat_dict.items():
        # .split(".")[0] extracts the part to the left of the dot (if there is one)
        if old_material.split(".")[0] == k:
            return v
    return old_material

for obj in objects:
    for slot in obj.material_slots:
        new_material = get_new_material(slot.material.name)
        slot.material = bpy.data.materials[new_material]

Instead of the .split(".")[0] you could use or re.match by storing regexes as keys in your dictionary. As you noticed in the comment, startswith could match too much, and the same would be the case for fnmatch.

Examples of the above function in action:

In [3]: get_new_material("SOLID-WHITE.001")
Out[3]: 'Sld_WHITE'

In [4]: get_new_material("SOLID-WHITE")
Out[4]: 'Sld_WHITE'

In [5]: get_new_material("SOLID-BLACK")
Out[5]: 'Sld_BLACK'

In [6]: get_new_material("test")
Out[6]: 'test'