How do I check if nested dictionary has a value of a specific type in Python?

I want to know how I can check if a dictionary with key-value pairs, where the values can be of any python type that contains my custom object.

Lets say object is called MyObject and I have a dictionary.

{
   "test1": MyObject()
   "test2": [MyObject(), MyObject()]
   "test3": {"some_key": MyObject()]
   "test4": {"some_key": [MyObject()]
   "test5": (MyObject(), MyObject()) # tuple
   "test6": {MyObject(), MyObject()} # set
   "test7": {"some_key1": {"some_key2": {"some_key3": MyObject()}}}
   ....
}

I want to be able to check if any of these values are or contain an instance of my custom object. Is this possible?

I Have tried:

def contains_object(d):
   for k,v in d.items():
      if isinstance(v, MyObject):
         return True
      elif isinstance(v, (list, set, tuple)):
         for i in v:
            if isinstance(i, MyObject):
               return True
      elif isinstance(v, dict):
         for a, b in v.items():
            if isinstance(b, MyObject):
               return True
   return False

How do I simplify the above solution. It should return a boolean for whether or not the dictionary has any value that contains MyObject.

Something like this should work in most cases or at least serve as a good starting point for further expansion. It is based on simple recursion as suggested in the comments

def contains_target_type(element, target_type):
    if isinstance(element, target_type):
        return True
    elif isinstance(element, dict):
        for value in element.values():
            if contains_target_type(value, target_type):
                return True
    elif isinstance(element, (list, set, tuple)):
        for value in element:
            if contains_target_type(value, target_type):
                return True
    return False

You can call it like:

target_type = MyObject
flag = contains_target_type(dict_test_data, target_type)

You need a recursive approach that allows you to navigate any possible nesting within your dictionary.

The following code will do that. It will print the key that's associated with the value matching the custom class. If the custom class instance is within an iterable, the associated key will only be reported once.

class MyObject:
    ...


_dict = {
   "test1": MyObject(),
   "test2": [MyObject(), MyObject()],
   "test3": {"some_key": MyObject()},
   "test4": {"some_key": [MyObject()]},
   "test5": (MyObject(), MyObject()),
   "test6": {MyObject(), MyObject()},
   "test7": {"some_key1": {"some_key2": {"some_key3": MyObject()}}}
}

def parse(d):
    key = None
    def _parse(d):
        nonlocal key
        if isinstance(d, MyObject):
            print(key)
            return True
        if isinstance(d, dict):
            for key, v in d.items():
                _parse(v)
        elif isinstance(d, (list, set, tuple)):
            for v in d:
                if _parse(v) is True:
                    break
    _parse(d)

parse(_dict)

Output:

test1
test2
some_key
some_key
test5
test6
some_key3

You can simplify the code such like this:

def check_for_custom_object(data):
    if isinstance(data, MyObject):
        # do something with MyObject
    
    elif isinstance(data, (list, set, tuple)):
        for item in data:
            check_for_custom_object(item)
        
    elif isinstance(data, dict):
        for value in data.values():
            check_for_custom_object(value)