Exemplo n.º 1
0
        def getSymbolDataInstanceForDateDictionaryDataPoints(symbol_key_list_tuple):
            """
            :param list symbol_data_list: This is a list whose elements are tuples of the form (Key, Value) where each
                                            Key is a stock symbol and each Value is a list of comma-delimited strings,
                                            each representing a date's worth of stock data

            :return: tuple (key, value)|None: The returned key is a stock's symbol while the returned value is an object of
                                                type SymbolData. The symbol data object will contain the data which was
                                                contained in the list of comma-delimited strings. However if the list
                                                is empty, a value of None will be returned
            """

            # Index 1 of the symbol_key_list_tuple contains the list of comma-delimited strings
            symbol_data_list = symbol_key_list_tuple[1]
            if len(symbol_data_list) < 1:
                # If the stock had no data points within the time-frame specified by dateIntervalDictionary, return a
                #    None value
                return SymbolData(None)

            # Index 0 of the symbol_key_list_tuple contains the stock symbol
            symbol_code = symbol_key_list_tuple[0]
            # Instantiate the SymbolData object
            symbolDataInstance = SymbolData(symbol_code)

            # Iterate over the strings of stock-date data in the list
            for symbol_date_data in symbol_data_list:

                # We have an eventual data point which will operate on the stock's close price and percentage delta,
                #       so record those values if this symbol_date_data string is specific to today's date
                date = symbol_date_data[StockRdd.DATE_INDEX]
                if date == today_date:
                    symbolDataInstance.setTodayPrice(symbol_date_data[StockRdd.CLOSE_PRICE_INDEX])
                    symbolDataInstance.setTodayDeltaPercentage(symbol_date_data[StockRdd.DELTA_PERCENTAGE_INDEX])

                # Get all of the time spans which the date for this row belongs to
                date_interval_codes_for_date = dateIntervalDictionary.getIntervalCodesByDate(date)
                if not(date_interval_codes_for_date is None):
                    for date_interval_code in date_interval_codes_for_date:
                        # Add a value row for each span that this date belongs to
                        symbolDataInstance.addSpanValueByCode(date_interval_code, date_interval_code, symbol_date_data[StockRdd.CLOSE_PRICE_INDEX],
                                                                  symbol_date_data[StockRdd.OPEN_PRICE_INDEX], symbol_date_data[StockRdd.HIGH_PRICE_INDEX],
                                                                  symbol_date_data[StockRdd.LOW_PRICE_INDEX], symbol_date_data[StockRdd.DELTA_INDEX],
                                                                  symbol_date_data[StockRdd.DELTA_PERCENTAGE_INDEX])

            # Return a tuple comprised of the stock symbol and the SymbolData object
            return (symbol_code, symbolDataInstance)
 def test_getSpanAverageByCode_and_getPercentageDeltaOffSpanAverage(self):
     testSymbolData = SymbolData('A')
     span_to_test = [1.34, 5.6, -3.5, -0.3, 2.2]
     span_expected_average = 1.068
     span_even_expected_average = 0.01333
     span_odd_expected_average = 2.65
     off_average_value_to_test = 1.12
     span_code = 'test_span'
     testSymbolData.initializeSpanByCode(span_code)
     first_expected_none_value = testSymbolData.getSpanAverageByCode(span_code)
     self.assertIsNone(first_expected_none_value, 'A None value was not returned when getting the average of a span with no values')
     second_expected_none_value = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test)
     self.assertIsNone(second_expected_none_value, 'A None value was not returned when getting the percentage delta off average of a span with no values')
     unit_label_prefix = 'units_'
     i = 0
     for value in span_to_test:
         unit_label_suffix = 'even' if ((i % 2) == 0) else 'odd'
         unit_label = unit_label_prefix + unit_label_suffix
         unit_labels_list = [unit_label, i]
         testSymbolData.addSpanValueByCode(span_code, unit_labels_list, value)
         i += 1
     # Test average for all units in span
     span_test_average = testSymbolData.getSpanAverageByCode(span_code)
     self.assertEqual(span_expected_average, span_test_average, 'The computed average for a test span for a test SymbolData object was expected to be {0} but was {1}'.format(span_expected_average, span_test_average))
     expected_delta_off_average = 0.0486891385768
     test_delta_off_average = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test)
     test_delta_off_average = round(test_delta_off_average, 13)
     self.assertEqual(expected_delta_off_average, test_delta_off_average, 'The computed delta percentage off average for a test SymbolData object was expected to be {0} but was {1}'.format(expected_delta_off_average, test_delta_off_average))
     # Test average for odd/even units in span
     even_units_label = unit_label_prefix + 'even'
     test_even_units_average = testSymbolData.getSpanAverageByCode(span_code, even_units_label)
     test_even_units_average = round(test_even_units_average, 5)
     self.assertEqual(test_even_units_average, span_even_expected_average)
     odd_units_label = unit_label_prefix + 'odd'
     test_odd_units_average = testSymbolData.getSpanAverageByCode(span_code, odd_units_label)
     self.assertEqual(test_odd_units_average, span_odd_expected_average)
     # Test off-average for odd/even units in span
     expected_off_even_average_value = 83.0
     expected_off_odd_average_value = -0.57736
     test_delta_off_even_average = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test, even_units_label)
     test_delta_off_even_average = round(test_delta_off_even_average, 1)
     test_delta_off_odd_average = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test, odd_units_label)
     test_delta_off_odd_average = round(test_delta_off_odd_average, 5)
     self.assertEqual(expected_off_even_average_value, test_delta_off_even_average)
     self.assertEqual(expected_off_odd_average_value, test_delta_off_odd_average)
 def test_getSpanDeltaByCode(self):
     testSymbolData = SymbolData('A')
     span_code = 'test_span'
     testSymbolData.initializeSpanByCode(span_code)
     span_to_test = [[1.34, 1.10], [5.6, 1.0], [-3.5, 5.6], [-0.3, -3.5], [2.01, -0.3], [2.34, 2.01]]
     unit_label_prefix = 'units_'
     i = 0
     for unit_data in span_to_test:
         unit_label_suffix = 'even' if ((i % 2) == 0) else 'odd'
         unit_label = unit_label_prefix + unit_label_suffix
         unit_labels_list = [unit_label, i]
         close_price = unit_data[0]
         open_price = unit_data[1]
         testSymbolData.addSpanValueByCode(span_code, unit_labels_list, close_price, open_price)
         i += 1
     expected_span_delta = 1.24
     test_span_delta = testSymbolData.getSpanDeltaByCode(span_code)
     test_span_delta = round(test_span_delta, 2)
     self.assertEqual(expected_span_delta, test_span_delta)
     expected_span_delta_percentage = round(expected_span_delta / 1.10, 6)
     test_span_delta_percentage = round(testSymbolData.getSpanDeltaByCode(span_code, get_percentage = True), 6)
     self.assertEqual(expected_span_delta_percentage, test_span_delta_percentage)
     # Test the even/odd span deltas
     even_units_label = unit_label_prefix + 'even'
     odd_units_label = unit_label_prefix + 'odd'
     expected_even_units_delta = 0.91
     expected_odd_units_delta = 1.34
     test_even_units_delta = testSymbolData.getSpanDeltaByCode(span_code, even_units_label)
     test_even_units_delta = round(test_even_units_delta, 2)
     test_odd_units_delta = testSymbolData.getSpanDeltaByCode(span_code, odd_units_label)
     test_odd_units_delta = round(test_odd_units_delta, 2)
     self.assertEqual(expected_even_units_delta, test_even_units_delta)
     self.assertEqual(expected_odd_units_delta, test_odd_units_delta)
     test_even_units_delta_percentage = round(testSymbolData.getSpanDeltaByCode(span_code, even_units_label, get_percentage = True), 6)
     expected_even_units_delta_percentage = round(expected_even_units_delta / 1.10, 6)
     self.assertEqual(expected_even_units_delta_percentage, test_even_units_delta_percentage)
     test_odd_units_delta_percentage = round(testSymbolData.getSpanDeltaByCode(span_code, odd_units_label, get_percentage = True), 6)
     expected_even_units_delta_percentage = round(expected_odd_units_delta / 1.0, 6)
     self.assertEqual(expected_even_units_delta_percentage, test_odd_units_delta_percentage)
class TestSymbolData(unittest.TestCase):

    def tearDown(self):
        self.unitDeltaTestsSymbol = None
        self.emptySymbol = None

    def setUp(self):
        self.unit_delta_test_symbol = 'tud'
        self.unitDeltaTestsSymbol = SymbolData(self.unit_delta_test_symbol)
        self.tud_span_code = 'tud_span'
        self.unitDeltaTestsSymbol.initializeSpanByCode(self.tud_span_code)
        self.unit_label_one = 'unit_one'
        self.unit_delta_test_list_one = [0.3, 13.4, 0.8]
        self.unit_label_two = 'unit_two'
        self.unit_delta_test_list_two = [2.8, 13.7, 0.9]
        self.unit_label_three = 'unit_three'
        self.unit_delta_test_list_three = [10.9, 14.4, 15.3]
        self.unit_label_four = 'unit_four'
        self.unit_delta_test_list_four = [15.3, 16.3, 17.3]
        self.unit_label_five = 'unit_five'
        self.unit_delta_test_list_five = [37.3, 16.3, 34.1]
        self.unit_dict = {self.unit_label_one : self.unit_delta_test_list_one,
                          self.unit_label_two : self.unit_delta_test_list_two,
                          self.unit_label_three : self.unit_delta_test_list_three,
                          self.unit_label_four : self.unit_delta_test_list_four,
                          self.unit_label_five : self.unit_delta_test_list_five}
        for label, list_of_prices in self.unit_dict.items():
            for price in list_of_prices:
                self.unitDeltaTestsSymbol.addSpanValueByCode(self.tud_span_code, [label], close_price = price, open_price = price)
        self.max_unit_delta = 4.4
        self.max_unit_delta_label = self.unit_label_three
        self.min_unit_delta = -3.2
        self.min_unit_delta_label = self.unit_label_five
        self.max_unit_delta_percentage = 1.66667
        self.max_unit_delta_percentage_label = self.unit_label_one
        self.min_unit_delta_percentage = -0.678571429
        self.min_unit_delta_percentage_label = self.unit_label_two

        self.tud_span_code_two = 'tud_span_two'
        self.tud_span_two_unit_label_one = 'span_two_unit_one'
        self.tud_span_two_unit_delta_test_list_one = [14.3, 13.4, 115.1]
        self.tud_span_two_unit_label_two = 'span_two_unit_two'
        self.tud_span_two_unit_delta_test_list_two = [32.8, 13.7, 0.9]
        self.unitDeltaTestsSymbol.initializeSpanByCode(self.tud_span_code_two)
        self.unit_dict_two = {self.tud_span_two_unit_label_one : self.tud_span_two_unit_delta_test_list_one,
                              self.tud_span_two_unit_label_two : self.tud_span_two_unit_delta_test_list_two}
        for label, list_of_prices in self.unit_dict_two.items():
            for price in list_of_prices:
                self.unitDeltaTestsSymbol.addSpanValueByCode(self.tud_span_code_two, [label], close_price = price, open_price = price)
        self.max_unit_delta_two = 100.8
        self.max_unit_delta_percentage_two = 7.048951049
        self.max_unit_delta_label_two = self.tud_span_two_unit_label_one
        self.min_unit_delta_two = -31.9
        self.min_unit_delta_percentage_two = -0.972560976
        self.min_unit_delta_label_two = self.tud_span_two_unit_label_two
        self.expected_span_delta_value_to_span_max_delta_ratio = -3.045454545
        self.expected_span_delta_value_to_span_max_delta_percentage_ratio = -0.56224
        self.expected_span_delta_value_to_span_min_delta_ratio = 4.1875
        self.expected_span_delta_value_to_span_min_delta_percentage_ratio = 1.38093

        self.empty_symbol_code = 'empty'
        self.emptySymbol = SymbolData(self.empty_symbol_code)
        self.emptySymbol.initializeSpanByCode(self.tud_span_code)

        self.zero_delta_span_code = 'zero_delta'
        self.zero_delta_span = [1.34, 5.6, -3.5, -0.3, 1.34]
        self.zero_delta_span_off_average_test_value = 1.56
        self.unitDeltaTestsSymbol.initializeSpanByCode(self.zero_delta_span_code)
        for value in self.zero_delta_span:
            self.unitDeltaTestsSymbol.addSpanValueByCode(self.zero_delta_span_code, self.zero_delta_span_code, close_price = value, open_price = value)
        self.expected_percentage_delta_off_zero_delta_span_average = 0.7410714285714288

        self.zero_average_span_code = 'zero_average'
        self.zero_average_span = [1.34, 0.45, -1.65, -1.54, 1.4]
        self.unitDeltaTestsSymbol.initializeSpanByCode(self.zero_average_span_code)
        for value in self.zero_average_span:
            self.unitDeltaTestsSymbol.addSpanValueByCode(self.zero_average_span_code, self.zero_average_span_code, close_price = value, open_price = value)
        self.expected_percentage_delta_off_zero_delta_span_average = 0.7410714285714288

        self.span_unit_deltas = [-1.3, -1.5, .3, 4.4, 5.0, 1.1]
        self.expected_span_unit_min_delta = -1.5
        self.span_unit_delta_percentages = [-.13, -.15, .3, .4, -.04, 2.3]
        self.expected_unit_delta_percentage = -.15
        self.span_code_prefix = 'span_unit_'
        self.spanUnitDeltasSymbol = SymbolData('span_unit_deltas')
        for i in range(0, len(self.span_unit_deltas)):
            unit_delta = self.span_unit_deltas[i]
            unit_delta_percentage = self.span_unit_delta_percentages[i]
            span_code = self.span_code_prefix + str(i)
            self.spanUnitDeltasSymbol.addSpanValueByCode(span_code, [span_code], delta = unit_delta, delta_percentage = unit_delta_percentage)
            oscillating_span_code = self.span_code_prefix + str(i % 2)
            self.spanUnitDeltasSymbol.addSpanValueByCode(oscillating_span_code, [oscillating_span_code], delta = unit_delta, delta_percentage = unit_delta_percentage)

    def test_getMinSpanUnitDelta(self):
        test_min_unit_delta = self.spanUnitDeltasSymbol.getMinSpanUnitDelta()
        self.assertEqual(self.expected_span_unit_min_delta, test_min_unit_delta)
        test_min_unit_delta_percentage = self.spanUnitDeltasSymbol.getMinSpanUnitDelta(get_percentage_delta = True)
        self.assertEqual(test_min_unit_delta_percentage, self.expected_unit_delta_percentage)

    def test_getSpanByCode(self):
        zero_delta_span = self.unitDeltaTestsSymbol.getSpanByCode(self.zero_delta_span_code)
        self.assertEqual(self.zero_delta_span_code, zero_delta_span.code)
        self.assertEqual(zero_delta_span.getUnitsCount(), 5)
        tudSpan = self.unitDeltaTestsSymbol.getSpanByCode(self.tud_span_code)
        self.assertEqual(self.tud_span_code, tudSpan.code)
        self.assertEqual(15, tudSpan.getUnitsCount())
        tudSpanTwo = self.unitDeltaTestsSymbol.getSpanByCode(self.tud_span_code_two)
        self.assertEqual(self.tud_span_code_two, tudSpanTwo.code)
        self.assertEqual(6, tudSpanTwo.getUnitsCount())

    def test_getSpanUnitCount(self):
        self.assertEqual(self.unitDeltaTestsSymbol.getSpanUnitCount(self.zero_delta_span_code), 5)
        self.assertEqual(self.unitDeltaTestsSymbol.getSpanUnitCount(self.zero_average_span_code), 5)
        self.assertEqual(self.unitDeltaTestsSymbol.getSpanUnitCount(self.tud_span_code), 15)
        self.assertEqual(self.unitDeltaTestsSymbol.getSpanUnitCount(self.tud_span_code_two), 6)
        self.assertEqual(self.emptySymbol.getSpanUnitCount(self.tud_span_code), 0)

    def test_getPercentageDeltaOffSpanAverage(self):
        test_percentage_delta_off_zero_delta_span_average = self.unitDeltaTestsSymbol.getPercentageDeltaOffSpanAverage(self.zero_delta_span_code, self.zero_delta_span_off_average_test_value)
        self.assertEqual(test_percentage_delta_off_zero_delta_span_average, self.expected_percentage_delta_off_zero_delta_span_average)
        test_percentage_delta_off_zero_average_span_average = self.unitDeltaTestsSymbol.getPercentageDeltaOffSpanAverage(self.zero_average_span_code, self.zero_delta_span_off_average_test_value)
        self.assertEqual(test_percentage_delta_off_zero_average_span_average, float("inf"))

    def test_getSpanDeltaValueToSpanMaxDeltaRatio(self):
        test_max_ratio = round(self.unitDeltaTestsSymbol.getSpanDeltaValueToSpanMaxDeltaRatio(self.tud_span_code_two, self.tud_span_code), 9)
        self.assertEqual(test_max_ratio, self.expected_span_delta_value_to_span_max_delta_ratio)
        test_max_ratio_percentage = round(self.unitDeltaTestsSymbol.getSpanDeltaValueToSpanMaxDeltaRatio(self.tud_span_code_two, self.tud_span_code, True), 5)
        self.assertEqual(test_max_ratio_percentage, self.expected_span_delta_value_to_span_max_delta_percentage_ratio)
        test_percentage_delta_off_zero_delta_span_average = self.unitDeltaTestsSymbol.getSpanDeltaValueToSpanMaxDeltaRatio(self.tud_span_code_two, self.zero_delta_span_code)
        self.assertEqual(test_percentage_delta_off_zero_delta_span_average, float("inf"))

    def test_getSpanDeltaValueToSpanMinDeltaRatio(self):
        test_min_ratio = round(self.unitDeltaTestsSymbol.getSpanDeltaValueToSpanMinDeltaRatio(self.tud_span_code_two, self.tud_span_code), 4)
        self.assertEqual(test_min_ratio, self.expected_span_delta_value_to_span_min_delta_ratio)
        test_min_ratio_percentage = round(self.unitDeltaTestsSymbol.getSpanDeltaValueToSpanMinDeltaRatio(self.tud_span_code_two, self.tud_span_code, True), 5)
        self.assertEqual(test_min_ratio_percentage, self.expected_span_delta_value_to_span_min_delta_percentage_ratio)
        test_percentage_delta_off_zero_delta_span_average = self.unitDeltaTestsSymbol.getSpanDeltaValueToSpanMinDeltaRatio(self.tud_span_code_two, self.zero_delta_span_code)
        self.assertEqual(test_percentage_delta_off_zero_delta_span_average, float("inf"))

    def test_getMaxDeltaForSpan(self):
        test_max_delta_for_span_tud_one = self.unitDeltaTestsSymbol.getMaxDeltaForSpan(self.tud_span_code)
        test_max_value = test_max_delta_for_span_tud_one['delta']
        test_max_value_label = test_max_delta_for_span_tud_one['label']
        self.assertEqual(test_max_value, self.max_unit_delta)
        self.assertEqual(test_max_value_label, self.max_unit_delta_label)
        test_max_delta_percentage = self.unitDeltaTestsSymbol.getMaxDeltaForSpan(self.tud_span_code, True)
        test_max_delta_percentage_value = round(test_max_delta_percentage['delta'], 5)
        test_max_delta_percentage_label = test_max_delta_percentage['label']
        self.assertEqual(test_max_delta_percentage_value, self.max_unit_delta_percentage)
        self.assertEqual(test_max_delta_percentage_label, self.max_unit_delta_percentage_label)
        test_max_delta_two = self.unitDeltaTestsSymbol.getMaxDeltaForSpan(self.tud_span_code_two)
        test_max_value_two = test_max_delta_two['delta']
        test_max_value_label_two = test_max_delta_two['label']
        self.assertEqual(test_max_value_two, self.max_unit_delta_two)
        self.assertEqual(test_max_value_label_two, self.max_unit_delta_label_two)
        test_max_delta_percentage_two = self.unitDeltaTestsSymbol.getMaxDeltaForSpan(self.tud_span_code_two, True)
        test_max_delta_percentage_value_two = round(test_max_delta_percentage_two['delta'], 9)
        test_max_delta_percentage_label_two = test_max_delta_percentage_two['label']
        self.assertEqual(test_max_delta_percentage_value_two, self.max_unit_delta_percentage_two)
        self.assertEqual(test_max_delta_percentage_label_two, self.max_unit_delta_label_two)
        # Test empty Symbol
        test_empty_value = self.emptySymbol.getMaxDeltaForSpan(self.tud_span_code)
        test_value = test_empty_value['delta']
        test_label = test_empty_value['label']
        self.assertIsNone(test_value)
        self.assertIsNone(test_label)

    def test_getMaxDeltaForSpanValue(self):
        test_max_value_explicit = self.unitDeltaTestsSymbol.getMaxDeltaForSpanValue(self.tud_span_code)
        self.assertEqual(test_max_value_explicit, self.max_unit_delta)
        test_max_delta_percentage_value_explicit = round(self.unitDeltaTestsSymbol.getMaxDeltaForSpanValue(self.tud_span_code, True), 5)
        self.assertEqual(test_max_delta_percentage_value_explicit, self.max_unit_delta_percentage)

    def test_getMinDeltaForSpan(self):
        test_min_delta_for_span_tud_one = self.unitDeltaTestsSymbol.getMinDeltaForSpan(self.tud_span_code)
        test_min_value = round(test_min_delta_for_span_tud_one['delta'], 2)
        test_min_value_label = test_min_delta_for_span_tud_one['label']
        self.assertEqual(test_min_value, self.min_unit_delta)
        self.assertEqual(test_min_value_label, self.min_unit_delta_label)
        test_min_delta_percentage = self.unitDeltaTestsSymbol.getMinDeltaForSpan(self.tud_span_code, True)
        test_min_delta_percentage_value = round(test_min_delta_percentage['delta'], 9)
        test_min_delta_percentage_label = test_min_delta_percentage['label']
        self.assertEqual(test_min_delta_percentage_value, self.min_unit_delta_percentage)
        self.assertEqual(test_min_delta_percentage_label, self.min_unit_delta_percentage_label)
        test_min_delta_two = self.unitDeltaTestsSymbol.getMinDeltaForSpan(self.tud_span_code_two)
        test_min_value_two = round(test_min_delta_two['delta'], 2)
        test_min_value_label_two = test_min_delta_two['label']
        self.assertEqual(test_min_value_two, self.min_unit_delta_two)
        self.assertEqual(test_min_value_label_two, self.min_unit_delta_label_two)
        test_min_delta_percentage_two = self.unitDeltaTestsSymbol.getMinDeltaForSpan(self.tud_span_code_two, True)
        test_min_delta_percentage_value_two = round(test_min_delta_percentage_two['delta'], 9)
        test_min_delta_percentage_label_two = test_min_delta_percentage_two['label']
        self.assertEqual(test_min_delta_percentage_value_two, self.min_unit_delta_percentage_two)
        self.assertEqual(test_min_delta_percentage_label_two, self.min_unit_delta_label_two)
        # Test empty Symbol
        test_empty_value = self.emptySymbol.getMinDeltaForSpan(self.tud_span_code)
        test_value = test_empty_value['delta']
        test_label = test_empty_value['label']
        self.assertIsNone(test_value)
        self.assertIsNone(test_label)

    def test_getMinDeltaForSpanValue(self):
        test_min_value_explicit = round(self.unitDeltaTestsSymbol.getMinDeltaForSpanValue(self.tud_span_code), 2)
        self.assertEqual(test_min_value_explicit, self.min_unit_delta)
        test_min_delta_percentage_explicit = round(self.unitDeltaTestsSymbol.getMinDeltaForSpanValue(self.tud_span_code, True), 9)
        self.assertEqual(test_min_delta_percentage_explicit, self.min_unit_delta_percentage)

    def test_init(self):
        expected_symbol = 'A'
        symbolDataTest = SymbolData(expected_symbol)
        test_symbol = symbolDataTest.symbol
        self.assertEqual(expected_symbol, test_symbol, 'A SymbolData object was initialized but its symbol was returned as {0} while expected to be {1}'.format(test_symbol, expected_symbol))

    def test_getTodayPrice(self):
        expected_today_price = 12.4
        symbolDataTest = SymbolData('A')
        symbolDataTest.setTodayPrice(expected_today_price)
        test_today_price = symbolDataTest.getTodayPrice()
        self.assertEqual(expected_today_price, test_today_price, 'A SymbolData object did not return the expected value when calling getTodayPrice(), expected {0} but returned {1}'.format(expected_today_price, test_today_price))

    def test_getSpanAverageByCode_and_getPercentageDeltaOffSpanAverage(self):
        testSymbolData = SymbolData('A')
        span_to_test = [1.34, 5.6, -3.5, -0.3, 2.2]
        span_expected_average = 1.068
        span_even_expected_average = 0.01333
        span_odd_expected_average = 2.65
        off_average_value_to_test = 1.12
        span_code = 'test_span'
        testSymbolData.initializeSpanByCode(span_code)
        first_expected_none_value = testSymbolData.getSpanAverageByCode(span_code)
        self.assertIsNone(first_expected_none_value, 'A None value was not returned when getting the average of a span with no values')
        second_expected_none_value = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test)
        self.assertIsNone(second_expected_none_value, 'A None value was not returned when getting the percentage delta off average of a span with no values')
        unit_label_prefix = 'units_'
        i = 0
        for value in span_to_test:
            unit_label_suffix = 'even' if ((i % 2) == 0) else 'odd'
            unit_label = unit_label_prefix + unit_label_suffix
            unit_labels_list = [unit_label, i]
            testSymbolData.addSpanValueByCode(span_code, unit_labels_list, value)
            i += 1
        # Test average for all units in span
        span_test_average = testSymbolData.getSpanAverageByCode(span_code)
        self.assertEqual(span_expected_average, span_test_average, 'The computed average for a test span for a test SymbolData object was expected to be {0} but was {1}'.format(span_expected_average, span_test_average))
        expected_delta_off_average = 0.0486891385768
        test_delta_off_average = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test)
        test_delta_off_average = round(test_delta_off_average, 13)
        self.assertEqual(expected_delta_off_average, test_delta_off_average, 'The computed delta percentage off average for a test SymbolData object was expected to be {0} but was {1}'.format(expected_delta_off_average, test_delta_off_average))
        # Test average for odd/even units in span
        even_units_label = unit_label_prefix + 'even'
        test_even_units_average = testSymbolData.getSpanAverageByCode(span_code, even_units_label)
        test_even_units_average = round(test_even_units_average, 5)
        self.assertEqual(test_even_units_average, span_even_expected_average)
        odd_units_label = unit_label_prefix + 'odd'
        test_odd_units_average = testSymbolData.getSpanAverageByCode(span_code, odd_units_label)
        self.assertEqual(test_odd_units_average, span_odd_expected_average)
        # Test off-average for odd/even units in span
        expected_off_even_average_value = 83.0
        expected_off_odd_average_value = -0.57736
        test_delta_off_even_average = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test, even_units_label)
        test_delta_off_even_average = round(test_delta_off_even_average, 1)
        test_delta_off_odd_average = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test, odd_units_label)
        test_delta_off_odd_average = round(test_delta_off_odd_average, 5)
        self.assertEqual(expected_off_even_average_value, test_delta_off_even_average)
        self.assertEqual(expected_off_odd_average_value, test_delta_off_odd_average)



    def test_getSpanDeltaByCode(self):
        testSymbolData = SymbolData('A')
        span_code = 'test_span'
        testSymbolData.initializeSpanByCode(span_code)
        span_to_test = [[1.34, 1.10], [5.6, 1.0], [-3.5, 5.6], [-0.3, -3.5], [2.01, -0.3], [2.34, 2.01]]
        unit_label_prefix = 'units_'
        i = 0
        for unit_data in span_to_test:
            unit_label_suffix = 'even' if ((i % 2) == 0) else 'odd'
            unit_label = unit_label_prefix + unit_label_suffix
            unit_labels_list = [unit_label, i]
            close_price = unit_data[0]
            open_price = unit_data[1]
            testSymbolData.addSpanValueByCode(span_code, unit_labels_list, close_price, open_price)
            i += 1
        expected_span_delta = 1.24
        test_span_delta = testSymbolData.getSpanDeltaByCode(span_code)
        test_span_delta = round(test_span_delta, 2)
        self.assertEqual(expected_span_delta, test_span_delta)
        expected_span_delta_percentage = round(expected_span_delta / 1.10, 6)
        test_span_delta_percentage = round(testSymbolData.getSpanDeltaByCode(span_code, get_percentage = True), 6)
        self.assertEqual(expected_span_delta_percentage, test_span_delta_percentage)
        # Test the even/odd span deltas
        even_units_label = unit_label_prefix + 'even'
        odd_units_label = unit_label_prefix + 'odd'
        expected_even_units_delta = 0.91
        expected_odd_units_delta = 1.34
        test_even_units_delta = testSymbolData.getSpanDeltaByCode(span_code, even_units_label)
        test_even_units_delta = round(test_even_units_delta, 2)
        test_odd_units_delta = testSymbolData.getSpanDeltaByCode(span_code, odd_units_label)
        test_odd_units_delta = round(test_odd_units_delta, 2)
        self.assertEqual(expected_even_units_delta, test_even_units_delta)
        self.assertEqual(expected_odd_units_delta, test_odd_units_delta)
        test_even_units_delta_percentage = round(testSymbolData.getSpanDeltaByCode(span_code, even_units_label, get_percentage = True), 6)
        expected_even_units_delta_percentage = round(expected_even_units_delta / 1.10, 6)
        self.assertEqual(expected_even_units_delta_percentage, test_even_units_delta_percentage)
        test_odd_units_delta_percentage = round(testSymbolData.getSpanDeltaByCode(span_code, odd_units_label, get_percentage = True), 6)
        expected_even_units_delta_percentage = round(expected_odd_units_delta / 1.0, 6)
        self.assertEqual(expected_even_units_delta_percentage, test_odd_units_delta_percentage)