Exemple #1
0
    def _get_prices_at_frequency_for_ibcontract_object_no_checking(
        self,
        contract_object_with_ib_broker_config,
        freq: Frequency,
        allow_expired: bool = False,
    ) -> futuresContractPrices:

        new_log = contract_object_with_ib_broker_config.log(self.log)

        price_data = self.ib_client.broker_get_historical_futures_data_for_contract(
            contract_object_with_ib_broker_config,
            bar_freq=freq,
            allow_expired=allow_expired,
        )

        if price_data is missing_data:
            new_log.warn("Something went wrong getting IB price data for %s" %
                         str(contract_object_with_ib_broker_config))
            price_data = futuresContractPrices.create_empty()

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

        ## It's important that the data is in local time zone so that this works
        price_data = price_data.remove_future_data()

        ## Ignore zeros if no volumes (if volume could be real price eg crude oil)
        price_data = price_data.remove_zero_prices_if_zero_volumes()

        return price_data
Exemple #2
0
    def _get_prices_at_frequency_for_contract_object_no_checking(self, contract_object: futuresContract,
                                                                 freq: str
                                                    ) -> futuresContractPrices:

        """
        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 = contract_object.log(self.log)

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

        price_data = self.ib_client.broker_get_historical_futures_data_for_contract(
            contract_object_with_ib_broker_config, bar_freq=freq)

        if price_data is missing_data:
            new_log.warn(
                "Something went wrong getting IB price data for %s" %
                str(contract_object))
            price_data = futuresContractPrices.create_empty()

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

        ## It's important that the data is in local time zone so that this works
        price_data = price_data.remove_future_data()

        ## Some contract data is marked to model, don't want this
        price_data = price_data.remove_zero_volumes()

        return price_data
Exemple #3
0
    def get_recent_bid_ask_tick_data_for_contract_object(
            self, contract_object, trade_list_for_multiple_legs=None):
        """
        Get last few price ticks

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

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

        tick_data = self.ibconnection.ib_get_recent_bid_ask_tick_data(
            contract_object_with_ib_data,
            trade_list_for_multiple_legs=trade_list_for_multiple_legs,
        )
        if tick_data is missing_contract:
            return missing_data

        tick_data_as_df = from_ib_bid_ask_tick_data_to_dataframe(tick_data)

        return tick_data_as_df
Exemple #4
0
    def cancel_market_data_for_contract_object(
            self, contract_object, trade_list_for_multiple_legs=None):
        """
        Returns my encapsulation of a ticker object

        :param contract_object:
        :param trade_list_for_multiple_legs:
        :return:
        """

        new_log = self.log.setup(
            instrument_code=contract_object.instrument_code,
            contract_date=contract_object.date_str,
        )

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

        self.ibconnection.cancel_market_data_for_contract_object(
            contract_object_with_ib_data,
            trade_list_for_multiple_legs=trade_list_for_multiple_legs,
        )
    def _get_prices_at_frequency_for_ibcontract_object_no_checking(
        self,
        contract_object_with_ib_broker_config,
        freq: Frequency,
        allow_expired: bool = False,
    ) -> futuresContractPrices:

        new_log = contract_object_with_ib_broker_config.log(self.log)

        price_data = self.ib_client.broker_get_historical_futures_data_for_contract(
            contract_object_with_ib_broker_config,
            bar_freq=freq,
            allow_expired=allow_expired,
        )

        if price_data is missing_data:
            new_log.warn("Something went wrong getting IB price data for %s" %
                         str(contract_object_with_ib_broker_config))
            return failure

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

        return futuresContractPrices(price_data)
Exemple #6
0
    def get_recent_bid_ask_tick_data_for_contract_object(
            self, contract_object: futuresContract) -> dataFrameOfRecentTicks:
        """
        Get last few price ticks

        :param contract_object: futuresContract
        :return:
        """
        new_log = contract_object.log(self.log)

        contract_object_with_ib_data = (
            self.futures_contract_data.get_contract_object_with_IB_data(
                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()

        tick_data = self.ib_client.ib_get_recent_bid_ask_tick_data(
            contract_object_with_ib_data)

        if tick_data is missing_contract:
            return missing_data

        tick_data_as_df = from_ib_bid_ask_tick_data_to_dataframe(tick_data)

        return tick_data_as_df
Exemple #7
0
    def _get_prices_at_frequency_for_contract_object_no_checking(
        self,
        contract_object: futuresContract,
        freq: Frequency,
        allow_expired=False,
    ) -> futuresContractPrices:
        """
        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 = contract_object.log(self.log)

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

        price_data = self._get_prices_at_frequency_for_ibcontract_object_no_checking(
            contract_object_with_ib_broker_config,
            freq=freq,
            allow_expired=allow_expired,
        )

        return price_data
    def get_ticker_object_for_contract_object(
        self, contract_object: futuresContract, trade_list_for_multiple_legs=None) -> ibTickerObject:

        """
        Returns my encapsulation of a ticker object

        :param contract_object:
        :param trade_list_for_multiple_legs:
        :return:
        """

        new_log = contract_object.log(self.log)

        contract_object_with_ib_data = (
            self.futures_contract_data.get_contract_object_with_IB_data(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()

        ticker_with_bs = self.ibconnection.get_ticker_object(
            contract_object_with_ib_data,
            trade_list_for_multiple_legs=trade_list_for_multiple_legs,
        )

        ticker_object = ibTickerObject(ticker_with_bs, self.ibconnection)

        return ticker_object
Exemple #9
0
    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
Exemple #10
0
    def _get_prices_for_contract_object_no_checking(
            self, futures_contract_object):
        """

        :param futures_contract_object: futuresContract
        :return: futuresContractPrices
        """
        self.log.label(
            instrument_code=futures_contract_object.instrument_code,
            contract_date=futures_contract_object.date_str,
        )

        try:
            quandl_contract = _quandlFuturesContract(futures_contract_object)
        except BaseException:
            self.log.warning(
                "Can't parse contract object to find the QUANDL identifier"
            )
            return futuresContractPrices.create_empty()

        try:
            contract_data = quandl.get(quandl_contract.quandl_identifier())
        except Exception as exception:
            self.log.warn(
                "Can't get QUANDL data for %s error %s"
                % (quandl_contract.quandl_identifier(), exception)
            )
            return futuresContractPrices.create_empty()

        try:
            data = quandlFuturesContractPrices(contract_data)
        except BaseException:
            self.log.error(
                "Quandl API error: data fields are not as expected %s"
                % ",".join(list(contract_data.columns))
            )
            return futuresContractPrices.create_empty()

        # apply multiplier
        factor = quandl_contract.get_dividing_factor()
        data = data / factor

        return data
Exemple #11
0
    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_str,
        )

        contract_object_with_ib_broker_config = (
            self.futures_contract_data.get_contract_object_with_IB_metadata(
                contract_object))
        if contract_object_with_ib_broker_config 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_broker_config, 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 #12
0
    def get_prices_for_contract_object(self, contract_object: futuresContract):
        """
        get all prices without worrying about frequency

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

        if self.has_data_for_contract(contract_object):
            return self._get_prices_for_contract_object_no_checking(
                contract_object)
        else:
            return futuresContractPrices.create_empty()
    def get_prices_for_contract_object(self, contract_object):
        """
        get some prices

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

        if self.has_data_for_contract(contract_object):
            return self._get_prices_for_contract_object_no_checking(
                contract_object)
        else:
            return futuresContractPrices.create_empty()
    def get_prices_at_frequency_for_contract_object(self,
                                                    contract_object,
                                                    freq="D"):
        """
        get some prices

        :param contract_object:  futuresContract
        :param freq: str; one of D, H, 5M, M, 10S, S
        :return: data
        """

        if self.has_data_for_contract(contract_object):
            return self._get_prices_at_frequency_for_contract_object_no_checking(
                contract_object, freq=freq)
        else:
            return futuresContractPrices.create_empty()
Exemple #15
0
    def cancel_market_data_for_order(self, order: ibBrokerOrder):
        contract_object = order.futures_contract
        trade_list_for_multiple_legs = order.trade

        new_log = order.log_with_attributes(self.log)

        contract_object_with_ib_data = (
            self.futures_contract_data.get_contract_object_with_IB_data(
                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()

        self.ib_client.cancel_market_data_for_contract_object(
            contract_object_with_ib_data,
            trade_list_for_multiple_legs=trade_list_for_multiple_legs,
        )
    def _get_prices_for_contract_object_no_checking(
        self, futures_contract_object: futuresContract
    ) -> futuresContractPrices:
        """
        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)
        config = self.config

        date_format = config.input_date_format
        date_time_column = config.input_date_index_name
        input_column_mapping = config.input_column_mapping
        skiprows = config.input_skiprows
        skipfooter = config.input_skipfooter
        multiplier = config.apply_multiplier
        inverse = config.apply_inverse

        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:
            log = futures_contract_object.log(self.log)
            log.warn("Can't find adjusted price file %s" % filename)
            return futuresContractPrices.create_empty()

        instrpricedata = instrpricedata.groupby(level=0).last()
        for col_name in ["OPEN", "HIGH", "LOW", "FINAL"]:
            column_series = instrpricedata[col_name]
            if inverse:
                column_series = 1 / column_series
            column_series *= multiplier
            instrpricedata[col_name] = column_series.round(2)

        instrpricedata = futuresContractPrices(instrpricedata)

        return instrpricedata
Exemple #17
0
    def get_prices_at_frequency_for_contract_object(
            self,
            contract_object: futuresContract,
            freq: Frequency = DAILY_PRICE_FREQ,
            return_empty: bool = True):
        """
        get some prices at a given frequency

        :param contract_object:  futuresContract
        :param freq: str; one of D, H, 5M, M, 10S, S
        :return: data
        """

        if self.has_data_for_contract(contract_object):
            return self._get_prices_at_frequency_for_contract_object_no_checking(
                contract_object, freq=freq)
        else:
            if return_empty:
                return futuresContractPrices.create_empty()
            else:
                return failure
Exemple #18
0
    def get_ticker_object_for_order(self, order: contractOrder) -> tickerObject:
        contract_object = order.futures_contract
        trade_list_for_multiple_legs = order.trade

        new_log = order.log_with_attributes(self.log)

        contract_object_with_ib_data = (
            self.futures_contract_data.get_contract_object_with_IB_data(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()

        ticker_with_bs = self.ib_client.get_ticker_object(
            contract_object_with_ib_data,
            trade_list_for_multiple_legs=trade_list_for_multiple_legs,
        )

        ticker_object = ibTickerObject(ticker_with_bs, self.ib_client)

        return ticker_object