Tukukkk

I wrote the python class below which does what I want it to do but the data structure is a mess. Was wondering if there was a better structure I could use to get the same results but also have the code be much more readable.

idea here is we retrieve a dataset from SQL(constructor), cluster the dataset into distinct keys(constructor), iterate through the keys and isolate the matching criteria in the dataset(organizer), pass those data chunks to map_loc_to_lat_long which will find all possible combinations of rows in the chunk and find the straight line distance between all the combination Lat Longs

class OrderProximityModel:

    def __init__(self, date):

        self.date = str(date)

        self.order_data = OrderProxDao().Load_Order_Lat_Long_Date_Zone_Data(self.date)

        self.distinct = set([str(row.Requirements) + ' ' + str(row.Route_Date) for row in self.order_data])





    def organizer(self):

        container = 

        for date_zone in self.distinct:

            latlng = list(filter(lambda x: str(x.Requirements) + ' ' + str(x.Route_Date) == date_zone, self.order_data))

            for i in self.map_loc_to_lat_long(latlng):

                container.append((i[0][0][0], i[0][0][1], i[0][0][2], i[0][0][4], i[0][0][5], i[0][0][6]))

        InsertHelpers(container).chunk_maker(100)

        return True





    def map_loc_to_lat_long(self, grouped_zone):

        converted = {}

        for row in grouped_zone:

            converted[row.LocationKey] = [row.Latitude, row.Longitude, row.DA, row.Route_Date, row.Requirements, row.DA]

        grouped_combos = self.combo_creator(converted.keys())

        return map(lambda combo: ([converted[combo[0]][2:] + [combo[0]] + [combo[1]] +

                                  [StraightLineDistance().dist_cal(converted[combo[0]][0],

                                                                   converted[combo[0]][1],

                                                                   converted[combo[1]][0],

                                                                   converted[combo[1]][1])]],

                                  ), grouped_combos)



    @staticmethod

    def combo_creator(inputs):

        out = 

        for index, value in enumerate(inputs):

            for nex_value in inputs[index + 1:]:

                out.append((value, nex_value))

        return out