

def iterate(self):
    if self._row:
        row = self._row.pop()
    else:
        row = self.cursor.fetchone()
    if (not row):
        self._populated = True
        if (not getattr(self.cursor, 'name', None)):
            self.cursor.close()
        raise StopIteration
    elif (not self._initialized):
        self.initialize(self.cursor.description)
        self._initialized = True

    def _get_pk(instance):
        if instance._meta.composite_key:
            return tuple([instance._data[field_name] for field_name in instance._meta.primary_key.field_names])
        return instance._get_pk_value()
    identity_map = {
        
    }
    _constructed = self.construct_instances(row)
    primary_instance = _constructed[self.model]
    for (model_or_alias, instance) in _constructed.items():
        identity_map[model_or_alias] = OrderedDict()
        identity_map[model_or_alias][_get_pk(instance)] = instance
    model_data = self.read_model_data(row)
    while True:
        cur_row = self.cursor.fetchone()
        if (cur_row is None):
            break
        duplicate_models = set()
        cur_row_data = self.read_model_data(cur_row)
        for (model_class, data) in cur_row_data.items():
            if (model_data[model_class] == data):
                duplicate_models.add(model_class)
        if (not duplicate_models):
            self._row.append(cur_row)
            break
        different_models = (self.all_models - duplicate_models)
        new_instances = self.construct_instances(cur_row, different_models)
        for (model_or_alias, instance) in new_instances.items():
            all_none = True
            for value in instance._data.values():
                if (value is not None):
                    all_none = False
            if (not all_none):
                identity_map[model_or_alias][_get_pk(instance)] = instance
    stack = [self.model]
    instances = [primary_instance]
    while stack:
        current = stack.pop()
        if (current not in self.join_meta):
            continue
        for join in self.join_meta[current]:
            try:
                (metadata, attr) = self.source_to_dest[current][join.dest]
            except KeyError:
                continue
            if (metadata.is_backref or metadata.is_self_join):
                for instance in identity_map[current].values():
                    setattr(instance, attr, [])
                if (join.dest not in identity_map):
                    continue
                for (pk, inst) in identity_map[join.dest].items():
                    if (pk is None):
                        continue
                    try:
                        joined_inst = identity_map[current][inst._data[metadata.foreign_key.name]]
                    except KeyError:
                        continue
                    getattr(joined_inst, attr).append(inst)
                    instances.append(self)
            elif attr:
                if (join.dest not in identity_map):
                    continue
                for (pk, instance) in identity_map[current].items():
                    joined_inst = identity_map[join.dest][instance._data[metadata.foreign_key.name]]
                    setattr(instance, metadata.foreign_key.name, joined_inst)
                    instances.append(joined_inst)
            stack.append(join.dest)
    for instance in instances:
        instance._prepare_instance()
    return primary_instance

dataset/ETHPy150Open coleifer/peewee/peewee.py AggregateQueryResultWrapper.iterate/VarMisuse@646/835 `inst`->`self`