<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def process_attributes_of_node(attrs, node_name, class_type):
 """ prepare the model fields, nodes and relations Args: node_name (str):
 name of the node we are currently processing attrs (dict):
 attribute dict class_type (str):
 Type of class. Can be one of these: 'ListNode', 'Model', 'Node' """

        # print("Node: %s" % node_name)
        attrs['_nodes'] = {}
        attrs['_linked_models'] = defaultdict(list)
        attrs['_debug_linked_models'] = defaultdict(list)
        attrs['_lazy_linked_models'] = defaultdict(list)
        attrs['_fields'] = {}
        attrs['_uniques'] = []
        # attrs['_many_to_models'] = []

        # iterating over attributes of the soon to be created class object.
        for key, attr in list(attrs.items()):
            # if it's a class (not instance) and it's type is Node or ListNode
            if hasattr(attr, '__base__') and getattr(attr.__base__, '_TYPE', '') in ['Node',
                                                                                     'ListNode']:
                # converted pops to dict access to allow sphinx to
                # properly document the models
                # attrs['_nodes'][key] = attrs.pop(key)
                attrs['_nodes'][key] = attrs[key]
            else:  # otherwise it should be a field or linked model
                attr_type = getattr(attr, '_TYPE', '')

                if attr_type == 'Model':
                    attrs['%s_id' % key] = ''
                    # lnk_mdl_ins = attrs.pop(key)
                    lnk_mdl_ins = attrs[key]
                    lnk = {
                        'null': lnk_mdl_ins.null or class_type == 'ListNode',
                        'link_source': True,
                        'mdl': lnk_mdl_ins.__class__,
                        'o2o': lnk_mdl_ins._is_one_to_one,
                        'm2m': class_type == 'ListNode',
                        'reverse': lnk_mdl_ins.reverse_name,
                        'verbose': lnk_mdl_ins.verbose_name,
                        'field': key,
                        'is_set': False,
                    }
                    attrs['_linked_models'][attr.__class__.__name__].append(lnk)
                    debug_lnk = lnk.copy()
                    debug_lnk['lnksrc']= 'process_attributes_of_node'
                    attrs['_debug_linked_models'][attr.__class__.__name__].append(debug_lnk)
                elif attr_type == 'Field':
                    attr.name = key
                    attrs['_fields'][key] = attr
                    if attr.unique:
                        attrs['_uniques'].append(key)
                elif attr_type == 'Link':
                    # lzy_lnk = attrs.pop(key)
                    attrs['%s_id' % key] = ''
                    lzy_lnk = attrs[key]
                    attrs['_lazy_linked_models'][key].append({'from': node_name,
                                                              'to': lzy_lnk.link_to,
                                                              'o2o': lzy_lnk.one_to_one,
                                                              'verbose': lzy_lnk.verbose_name,
                                                              'reverse': lzy_lnk.reverse_name,
                                                              'field': key})