Cleanup, implementation of historic averages series

---------------------------------------------------

* Removal of much dead code. YAGNI (but I will)
* Return (dt, price) where appropriate, calling that pair a "point"
* `SymbolComparison.normalized_price_history_averages`, spits out points of (dt, price) where "price" is the average of all known symbols

coincharts/data.py

@@ -17,19 +17,6 @@ class SymbolInfo(object):
    def __init__(self, symbol):
        self.symbol = symbol

    def normalize_price(self, price):
        return (price - self.min) / (self.max - self.min)

    def normalized_price_history(self):
        return map(self.normalize_price, self.history)

    @property
    @memoize
    def dt_range(self):
        start = self.history[0].dt
        end = self.history[len(self.history)-1].dt
        return start, end

    @property
    @memoize
    def min(self):
@@ -46,65 +33,43 @@ def history(self):
        return Prices.objects.filter(symbol=self.symbol)

    @property
    def normalized_price_history(self):
    def normalized_history(self):
        price_delta = self.max - self.min
        for price in self.history:
            yield (price.price - self.min) / price_delta
        for record in self.history:
            yield record.dt, (record.price - self.min) / price_delta


class SymbolComparison(dict):

    def __init__(self, *args, **kwargs):
        self.update(*args, **kwargs)

    @property
    @memoize
    def start_dt_indexes(self):
        indexes = {}
    def normalized_history_averages(self):
        normalized_history_generators = []
        for symbol, data in self.items():
            try:
                indexes[symbol] = [s.dt for s in data.history].index(self.earliest_common_dt)
            except ValueError:
                raise ValueError('Could not find datetime {} in history of {}'.format(
                    self.earliest_common_dt, symbol))
        return indexes

    @property
    @memoize
    def earliest_common_dt(self):
        return sorted([symbol.history[0].dt for symbol in self.values()])[0]

    def normalized_price_history_averages(self):
        normalized_price_history_generators = []
        for symbol, data in self.items():
            normalized_price_history_generators.append(
                data.normalized_price_history
            normalized_history_generators.append(
                data.normalized_history
            )
        num_prices = len(self)

        while True:
            prices = []
            for gen in normalized_price_history_generators:
            for gen in normalized_history_generators:
                try:
                    prices.append(gen.__next__())
                    point = gen.__next__()
                    # this means we end up using the dt value of the last point we get.
                    # this shouldn't matter, since they are *supposed* to all be the same.
                    # the validation of this and other things should be implemented.
                    dt, price = point
                    prices.append(price)
                except StopIteration:
                    return
                yield sum(prices) / num_prices
                yield dt, sum(prices) / num_prices

if __name__ == '__main__':

    symbol_info = SymbolComparison()
    comparison = SymbolComparison()
    for symbol in symbols:
        symbol_info[symbol] = SymbolInfo(symbol)

    # print('name\t\t\tmin\tmax\t\t\trange')
    # for name, info in symbol_info.items():
    #     print(name,
    #           info.min,
    #           info.max, '\t',
    #           info.dt_range, sep='\t')

    comparison = SymbolComparison(symbol_info)
        comparison[symbol] = SymbolInfo(symbol)

    for p in comparison.normalized_price_history_averages():
    for p in comparison.normalized_history_averages():
        print(p)