def get_prices_at_frequency_for_contract_object(self, contract_object, freq="D"):
        """
        Get historical prices at a particular frequency

        We override this method, rather than _get_prices_at_frequency_for_contract_object_no_checking
        Because the list of dates returned by contracts_with_price_data is likely to not match (expiries)

        :param contract_object:  futuresContract
        :param freq: str; one of D, H, 15M, 5M, M, 10S, S
        :return: data
        """
        new_log = self.log.setup(instrument_code=contract_object.instrument_code, contract_date=contract_object.date)

        contract_object_with_ib_data = self.futures_contract_data.get_contract_object_with_IB_metadata(contract_object)
        if contract_object_with_ib_data is missing_contract:
            new_log.warn("Can't get data for %s" % str(contract_object))
            return futuresContractPrices.create_empty()

        price_data = self.ibconnection.broker_get_historical_futures_data_for_contract(contract_object_with_ib_data,
                                                                                       bar_freq = freq)

        if len(price_data)==0:
            new_log.warn("No IB price data found for %s" % str(contract_object))
            data = futuresContractPrices.create_empty()
        else:
            data = futuresContractPrices(price_data)

        data = futuresContractPrices(data[data.index<datetime.datetime.now()])
        data = data.remove_zero_volumes()

        return data
Exemple #2
0
    def get_prices_for_contract_object(self, contract_object):
        """
        Get some prices
        (daily frequency: using IB historical data)

        :param contract_object:  futuresContract
        :return: data
        """
        new_log = self.log.setup(
            instrument_code=contract_object.instrument_code,
            contract_date=contract_object.date)

        contract_object_with_ib_data = self._get_contract_object_with_IB_metadata(
            contract_object)
        if contract_object_with_ib_data is missing_contract:
            new_log.warn("Can't get data for %s" % str(contract_object))
            return futuresContractPrices.create_empty()

        price_data = self.ibconnection.broker_get_historical_futures_data_for_contract(
            contract_object_with_ib_data, bar_freq="D")

        if len(price_data) == 0:
            new_log.msg("No IB price data found for %s" % str(contract_object))
            data = futuresContractPrices.create_empty()
        else:
            data = futuresContractPrices(price_data)

        data = futuresContractPrices(
            data[data.index < datetime.datetime.now()])
        data = data.remove_zero_volumes()

        return data
Exemple #3
0
    def get_prices_for_contract_object(self, contract_object):
        """
        Get some prices
        (daily frequency: using IB historical data)

        We override this method, rather than _get_prices_for_contract_object_no_checking
        Because the list of dates returned by contracts_with_price_data is likely to not match (expiries)

        :param contract_object:  futuresContract
        :return: data
        """
        new_log = self.log.setup(
            instrument_code=contract_object.instrument_code,
            contract_date=contract_object.date)

        contract_object_with_ib_data = self._get_contract_object_with_IB_metadata(
            contract_object)
        if contract_object_with_ib_data is missing_contract:
            new_log.warn("Can't get data for %s" % str(contract_object))
            return futuresContractPrices.create_empty()

        price_data = self.ibconnection.broker_get_historical_futures_data_for_contract(
            contract_object_with_ib_data, bar_freq="D")

        if len(price_data) == 0:
            new_log.msg("No IB price data found for %s" % str(contract_object))
            data = futuresContractPrices.create_empty()
        else:
            data = futuresContractPrices(price_data)

        return data
    def _get_prices_for_contract_object_no_checking(self,
                                                    futures_contract_object):
        """
        Read back the prices for a given contract object

        :param contract_object:  futuresContract
        :return: data
        """
        keyname = self._keyname_given_contract_object(futures_contract_object)
        filename = self._filename_given_key_name(keyname)

        date_format = self._input_date_format
        date_time_column = self._input_date_time_column
        input_column_mapping = self._input_column_mapping
        skiprows = self._input_skiprows
        skipfooter = self._input_skipfooter

        try:
            instrpricedata = pd_readcsv(
                filename,
                date_index_name=date_time_column,
                date_format=date_format,
                input_column_mapping=input_column_mapping,
                skiprows=skiprows,
                skipfooter=skipfooter)
        except OSError:
            self.log.warning("Can't find adjusted price file %s" % filename)
            return futuresContractPrices.create_empty()

        instrpricedata = instrpricedata.groupby(level=0).last()

        instrpricedata = futuresContractPrices(instrpricedata)

        return instrpricedata
    def _get_prices_for_contract_object_no_checking(self, futures_contract_object):
        """
        Read back the prices for a given contract object

        :param contract_object:  futuresContract
        :return: data
        """

        ident = self._keyname_given_contract_object(futures_contract_object)
        item = self._arctic.library.read(ident)

        ## What if not found? CHECK

        ## Returns a data frame which should have the right format
        data = item.data

        return futuresContractPrices(data)
    def _get_prices_for_contract_object_no_checking(self, futures_contract_object):
        """
        Read back the prices for a given contract object

        :param contract_object:  futuresContract
        :return: data
        """

        ident = self._keyname_given_contract_object(futures_contract_object)
        item = self._arctic.library.read(ident)

        ## What if not found? CHECK

        ## Returns a data frame which should have the right format
        data = item.data

        return futuresContractPrices(data)