Cfrtjryk

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 with better readable code.

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

self.date = str(date)

This is a pet peeve of mine. Stringly-typed variables are usually a bad idea. If you receive a datetime object, you should usually keep it as datetime until you actually need it to be a string.

Load_Order_Lat_Long_Date_Zone_Data

If at all possible, shorten this method name. Also, methods are lowercase by convention.

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

Here you make a generator, construct a list and then convert it to a set. Skip the list - the set constructor can accept generators directly. Better yet, if you're in a sane version of Python, just use a set literal (and use a format string):

self.distinct = {'%s %s' % (row.Requirements, row.Route_Date) for row in self.order_data}

Your container = / container.append() loop can be replaced by proper use of a generator. Same with out.

latlng does not (and should not) be materialized to a list. It should be left as a generator, since you only iterate over it once.

This:

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]))

can be:

container.append(tuple(i[0][0][j] for j in (0, 1, 2, 4, 5, 6)))