Recursively patching the properties of an ORM model and related models

If we assume that either for loop can come before or after the other for loop. Then you should check if anhaenge is not None. As your except TypeError is to guard against that. You can then return from the function after you log the error, remove the except TypeError, remove the duplicate for loop, and finally, put the duplicate for loop after the if, as you wish to perform the loop here on either branch. EG:

try:
    anhaenge = d['anhaenge']
except KeyError:
    self.logger.debug('anhaenge unchanged')
else:
    if anhaenge is not None:
        try:
            anhang = anhaenge['anhang']:
        except KeyError:
            self.logger.debug('anhaenge.anhang unchanged')
            return
        else:
            for anhang_ in anhang:
                with suppress(EmptyDict):
                    for record in Anhang.from_dict(anhang_, immobilie=self):
                        yield record, PatchMode.CREATE
    for record in self.anhang:
        yield (record, PatchMode.DELETE)

But this is not possible if the duplicated for loop has to occur before the other for loop.

Either way, I honestly don't think you're input is right. Your input is strange, None is normally used to say it's not there, and so dict.get('a', None) is a common occurrence. However your code performs differently whether it's None or not there. And so I'd say you should restructure the input so you can use say:

anhang = d.get('anhaenge', {}).get('anhang', None)
if anhang:
    for record in self.anhang:
        yield (record, PatchMode.DELETE)

    for anhang_ in anhang:
        with suppress(EmptyDict):
            for record in Anhang.from_dict(
                    anhang_, immobilie=self):
                yield (record, PatchMode.CREATE)
else:
    self.logger.debug('anhaenge or anhaenge.anhang is unchanged')

If you can't adapt either of the above, then I'd say your code is good for your situation.

So, you want to delete old records if d['anhaenge']['anhang'] is present, whatever its value. And if it is not None, you want to update with new values as well.

The catch being that d may not contain the 'anhaenge' key, or the value for that key may be None. Looking at the except TypeError, the behaviour seems to be the same if you have d = {'anhaenge': None} and d = {'anhaenge': {'anhang': None}}. But d not containing 'anhaenge' should do nothing.

Since you say it's part of a method, you may extract a behaviour into its own function to benefit from early return: get a dictionnary of new values for 'anhang', or None if it shouldn't be changed:

def extract_anhang(d):
    try:
        anhaenge = d['anhaenge']
    except KeyError:
        self.logger.debug('anhaenge unchanged')
        return

    if anhaenge is None:
        return {}

    try:
        anhang = anhaenge['anhang']
    except KeyError:
        self.logger.debug('anhaenge.anhang unchanged')
        return
    return {} if anhang is None else anhang

and then, you can simplify your method into:

anhang = extract_anhang(d)
if anhang is not None:
    for record in self.anhang:
        yield (record, PatchMode.DELETE)

    for anhang_ in anhang:
        with suppress(EmptyDict):
            for record in Anhang.from_dict(anhang_, immobilie=self):
                yield (record, PatchMode.CREATE)

You can also use the same function to handle other subkeys similarly. Just parametrize it by the name of the subkey:

def extract_subkey(container, primarykey, subkey):
    try:
        subcontainer = container[primarykey]
    except KeyError:
        self.logger.debug('%s unchanged', primarykey)
        return

    if subcontainer is None:
        return {}

    try:
        subvalue = subcontainer[subkey]
    except KeyError:
        self.logger.debug('%s.%s unchanged', primarykey, subkey)
        return
    return {} if subvalue is None else subvalue

And the call become

anhang = extract_subkey(d, 'anhaenge', 'anhang')

In case you really prefer the TypeError approach (but I wouldn't use it as your comment suggest it is "probably" not the right approach), you can still use it instead of that if:

def extract_subkey(container, primarykey, subkey):
    try:
        subcontainer = container[primarykey]
    except KeyError:
        self.logger.debug('%s unchanged', primarykey)
        return

    try:
        subvalue = subcontainer[subkey]
    except TypeError:
        # subcontainer is probably None
        return {}
    except KeyError:
        self.logger.debug('%s.%s unchanged', primarykey, subkey)
        return
    return {} if subvalue is None else subvalue

In the end, nothing much changes, as this versions provide the same flow than yours, but early returns makes it more readable. You still have your two repeated blocks of code but they are now return {} and, even though they are linked to the logic, they don't contain some on their own; so it's better for maintainability.

If you still want to keep your logging you can use something like this.

anhaenge = d.get('anhaenge')

if anhaenge is None:
    self.logger.debug('anhaenge unchanged')
    return

anhang = anhaenge.get('anhang')
if anhang is None:
    self.logger.debug('anhaenge.anhang unchanged')
    return

for record in self.anhang:
    yield (record, PatchMode.DELETE)

for anhang_ in anhang:
    with suppress(EmptyDict):
        for record in Anhang.from_dict(
                anhang_, immobilie=self):
            yield (record, PatchMode.CREATE)