def list_current_orders(self,
                            bet_ids=None,
                            market_ids=None,
                            order_projection=None,
                            date_range=None,
                            order_by=None,
                            sort_dir=None,
                            from_record=None,
                            record_count=None):
        """

        :param bet_ids:
        :param market_ids:
        :param order_projection:
        :param date_range:
        :param order_by:
        :param sort_dir:
        :param from_record:
        :param record_count:
        """
        return self.make_api_request(
            'Sports',
            'listCurrentOrders',
            utils.get_kwargs(locals()),
            model=models.CurrentOrderSummaryReport,
        )
Exemple #2
0
def list_cleared_orders(self, bet_status, event_type_ids, event_ids,
                        market_ids, runner_ids, bet_ids, side,
                        settled_date_range, group_by, include_item_description,
                        locale, from_record, record_count):
    """

    :param bet_status:
    :param event_type_ids:
    :param event_ids:
    :param market_ids:
    :param runner_ids:
    :param bet_ids:
    :param side:
    :param settled_date_range:
    :param group_by:
    :param include_item_description:
    :param locale:
    :param from_record:
    :param record_count:

    """
    clearedOrders = self.make_api_request(
        'listClearedOrders',
        utils.get_kwargs(locals()),
        model=None,
    )
    return list_orders(clearedOrders, 'clearedOrders')
def list_market_book(
        self, market_ids, price_projection=None, order_projection=None,
        match_projection=None, currency_code=None, locale=None):
    """

    :param list market_ids: List of market IDs
    :param PriceProjection price_projection:
    :param OrderProjection order_projection:
    :param MatchProjection match_projection:
    :param str currency_code:
    :param str locale:

    """
    books=self.make_api_request(
        'listMarketBook',
        utils.get_kwargs(locals()),
        model=None,
    )
    return {'market.book':market_books(books),
    'runners':runners(books),
    'runners.sp':runners_sp(books),
    'runners.sp.backStakeTaken':runners_prices(books,'sp','backStakeTaken'),
    'runners.sp.layLiabilityTaken':runners_prices(books,'sp','layLiabilityTaken'),
    'runners.ex.availableToBack':runners_prices(books,'ex','availableToBack'),
    'runners.ex.availableToLay':runners_prices(books,'ex','availableToLay'),
    'runners.ex.tradedVolume':runners_prices(books,'ex','tradedVolume'),
    'runners.orders':runners_orders(books,'orders'),
    'runners.matches':runners_orders(books,'matches')}
Exemple #4
0
    def list_cleared_orders(
            self, bet_status, event_type_ids, event_ids, market_ids,
            runner_ids, bet_ids, side, settled_date_range, group_by,
            include_item_description, locale, from_record, record_count):
        """

        :param bet_status:
        :param event_type_ids:
        :param event_ids:
        :param market_ids:
        :param runner_ids:
        :param bet_ids:
        :param side:
        :param settled_date_range:
        :param group_by:
        :param include_item_description:
        :param locale:
        :param from_record:
        :param record_count:
        """
        return self.make_api_request(
            'Sports',
            'listClearedOrders',
            utils.get_kwargs(locals()),
            model=models.ClearedOrderSummaryReport,
        )
Exemple #5
0
 def get_account_details(self):
     """Returns the details relating your account, including your discount
     rate and Betfair point balance.
     """
     return self.make_api_request(
         'Account',
         'getAccountDetails',
         utils.get_kwargs(locals()),
         model=models.AccountDetailsResponse,
     )
Exemple #6
0
 def get_account_details(self):
     """Returns the details relating your account, including your discount
     rate and Betfair point balance.
     """
     return self.make_api_request(
         'Account',
         'getAccountDetails',
         utils.get_kwargs(locals()),
         model=models.AccountDetailsResponse,
     )
Exemple #7
0
    def list_currency_rates(self, from_currency=None):
        """Returns a list of currency rates based on given currency

        :param str from_currency: The currency from which the rates are computed
        """
        return self.make_api_request(
            'Account',
            'listCurrencyRates',
            utils.get_kwargs(locals()),
            model=models.CurrencyRate,
        )
Exemple #8
0
    def get_account_funds(self, wallet=None):
        """Get available to bet amount.

        :param Wallet wallet: Name of the wallet in question
        """
        return self.make_api_request(
            'Account',
            'getAccountFunds',
            utils.get_kwargs(locals()),
            model=models.AccountFundsResponse,
        )
Exemple #9
0
    def list_currency_rates(self, from_currency=None):
        """Returns a list of currency rates based on given currency

        :param str from_currency: The currency from which the rates are computed
        """
        return self.make_api_request(
            'Account',
            'listCurrencyRates',
            utils.get_kwargs(locals()),
            model=models.CurrencyRate,
        )
Exemple #10
0
    def get_account_funds(self, wallet=None):
        """Get available to bet amount.

        :param Wallet wallet: Name of the wallet in question
        """
        return self.make_api_request(
            'Account',
            'getAccountFunds',
            utils.get_kwargs(locals()),
            model=models.AccountFundsResponse,
        )
Exemple #11
0
    def list_venues(self, filter=None, locale=None):
        """

        :param MarketFilter filter:
        :param str locale:
        """
        filter = filter or models.MarketFilter()
        return self.make_api_request(
            'Sports',
            'listCountries',
            utils.get_kwargs(locals()),
            model=models.VenueResult,
        )
Exemple #12
0
    def list_time_ranges(self, granularity, filter=None):
        """

        :param TimeGranularity granularity:
        :param MarketFilter filter:
        """
        filter = filter or models.MarketFilter()
        return self.make_api_request(
            'Sports',
            'listTimeRanges',
            utils.get_kwargs(locals()),
            model=models.TimeRangeResult,
        )
Exemple #13
0
    def list_time_ranges(self, granularity, filter=None):
        """

        :param TimeGranularity granularity:
        :param MarketFilter filter:
        """
        filter = filter or models.MarketFilter()
        return self.make_api_request(
            'Sports',
            'listTimeRanges',
            utils.get_kwargs(locals()),
            model=models.TimeRangeResult,
        )
def list_competitions(self, filter, locale=None):
    """

    :param MarketFilter filter:
    :param str locale:

    """
    listCompetitions=self.make_api_request(
        'listCompetitions',
        utils.get_kwargs(locals()),
        model=None,
    )
    return flatten_simple_list(listCompetitions,'competition')
Exemple #15
0
    def transfer_funds(self, from_, to, amount):
        """Transfer funds between the UK Exchange and Australian Exchange wallets.

        :param Wallet from_: Source wallet
        :param Wallet to: Destination wallet
        :param float amount: Amount to transfer
        """
        return self.make_api_request(
            'Account',
            'transferFunds',
            utils.get_kwargs(locals()),
            model=models.TransferResponse,
        )
Exemple #16
0
    def list_venues(self, filter=None, locale=None):
        """

        :param MarketFilter filter:
        :param str locale:
        """
        filter = filter or models.MarketFilter()
        return self.make_api_request(
            'Sports',
            'listVenues',
            utils.get_kwargs(locals()),
            model=models.VenueResult,
        )
Exemple #17
0
    def transfer_funds(self, from_, to, amount):
        """Transfer funds between the UK Exchange and Australian Exchange wallets.

        :param Wallet from_: Source wallet
        :param Wallet to: Destination wallet
        :param float amount: Amount to transfer
        """
        return self.make_api_request(
            'Account',
            'transferFunds',
            utils.get_kwargs(locals()),
            model=models.TransferResponse,
        )
def list_time_ranges(self, filter, granularity):
    """

    :param MarketFilter filter:
    :param TimeGranularity granularity:

    """
    listTimeRanges=self.make_api_request(
        'listTimeRanges',
        utils.get_kwargs(locals()),
        model=None,
    )
    return flatten_simple_list(listTimeRanges,'timeRange')
Exemple #19
0
def list_time_ranges(self, filter, granularity):
    """

    :param MarketFilter filter:
    :param TimeGranularity granularity:

    """
    listTimeRanges = self.make_api_request(
        'listTimeRanges',
        utils.get_kwargs(locals()),
        model=None,
    )
    return flatten_simple_list(listTimeRanges, 'timeRange')
Exemple #20
0
def list_competitions(self, filter, locale=None):
    """

    :param MarketFilter filter:
    :param str locale:

    """
    listCompetitions = self.make_api_request(
        'listCompetitions',
        utils.get_kwargs(locals()),
        model=None,
    )
    return flatten_simple_list(listCompetitions, 'competition')
Exemple #21
0
def list_venues(self, filter, locale=None):
    """

    :param MarketFilter filter:
    :param str locale:

    """
    listVenues = self.make_api_request(
        'listVenues',
        utils.get_kwargs(locals()),
        model=None,
    )
    return flatten_simple_list(listVenues, 'venue')
Exemple #22
0
    def update_orders(self, market_id, instructions, customer_ref=None):
        """Update non-exposure changing fields.

        :param str market_id: The market id these orders are to be placed on
        :param list instructions: List of `UpdateInstruction` objects
        :param str customer_ref: Optional order identifier string
        """
        return self.make_api_request(
            'Sports',
            'updateOrders',
            utils.get_kwargs(locals()),
            model=models.UpdateExecutionReport,
        )
Exemple #23
0
    def update_orders(self, market_id, instructions, customer_ref=None):
        """Update non-exposure changing fields.

        :param str market_id: The market id these orders are to be placed on
        :param list instructions: List of `UpdateInstruction` objects
        :param str customer_ref: Optional order identifier string
        """
        return self.make_api_request(
            'Sports',
            'updateOrders',
            utils.get_kwargs(locals()),
            model=models.UpdateExecutionReport,
        )
def list_venues(self, filter, locale=None):
    """

    :param MarketFilter filter:
    :param str locale:

    """
    listVenues=self.make_api_request(
        'listVenues',
        utils.get_kwargs(locals()),
        model=None,
    )
    return flatten_simple_list(listVenues,'venue')
Exemple #25
0
    def place_orders(self, market_id, instructions, customer_ref=None):
        """Place new orders into market. This operation is atomic in that all
        orders will be placed or none will be placed.

        :param str market_id: The market id these orders are to be placed on
        :param list instructions: List of `PlaceInstruction` objects
        :param str customer_ref: Optional order identifier string
        """
        return self.make_api_request(
            'Sports',
            'placeOrders',
            utils.get_kwargs(locals()),
            model=models.PlaceExecutionReport,
        )
Exemple #26
0
    def cancel_orders(self, market_id, instructions, customer_ref=None):
        """Cancel all bets OR cancel all bets on a market OR fully or
        partially cancel particular orders on a market.

        :param str market_id: If not supplied all bets are cancelled
        :param list instructions: List of `CancelInstruction` objects
        :param str customer_ref: Optional order identifier string
        """
        return self.make_api_request(
            'Sports',
            'cancelOrders',
            utils.get_kwargs(locals()),
            model=models.CancelExecutionReport,
        )
Exemple #27
0
    def replace_orders(self, market_id, instructions, customer_ref=None):
        """This operation is logically a bulk cancel followed by a bulk place.
        The cancel is completed first then the new orders are placed.

        :param str market_id: The market id these orders are to be placed on
        :param list instructions: List of `ReplaceInstruction` objects
        :param str customer_ref: Optional order identifier string
        """
        return self.make_api_request(
            'Sports',
            'replaceOrders',
            utils.get_kwargs(locals()),
            model=models.ReplaceExecutionReport,
        )
Exemple #28
0
    def replace_orders(self, market_id, instructions, customer_ref=None):
        """This operation is logically a bulk cancel followed by a bulk place.
        The cancel is completed first then the new orders are placed.

        :param str market_id: The market id these orders are to be placed on
        :param list instructions: List of `ReplaceInstruction` objects
        :param str customer_ref: Optional order identifier string
        """
        return self.make_api_request(
            'Sports',
            'replaceOrders',
            utils.get_kwargs(locals()),
            model=models.ReplaceExecutionReport,
        )
Exemple #29
0
    def place_orders(self, market_id, instructions, customer_ref=None):
        """Place new orders into market. This operation is atomic in that all
        orders will be placed or none will be placed.

        :param str market_id: The market id these orders are to be placed on
        :param list instructions: List of `PlaceInstruction` objects
        :param str customer_ref: Optional order identifier string
        """
        return self.make_api_request(
            'Sports',
            'placeOrders',
            utils.get_kwargs(locals()),
            model=models.PlaceExecutionReport,
        )
Exemple #30
0
    def cancel_orders(self, market_id, instructions, customer_ref=None):
        """Cancel all bets OR cancel all bets on a market OR fully or
        partially cancel particular orders on a market.

        :param str market_id: If not supplied all bets are cancelled
        :param list instructions: List of `CancelInstruction` objects
        :param str customer_ref: Optional order identifier string
        """
        return self.make_api_request(
            'Sports',
            'cancelOrders',
            utils.get_kwargs(locals()),
            model=models.CancelInstructionReport,
        )
Exemple #31
0
    def list_market_catalogue(
            self, filter=None, max_results=100, market_projection=None, locale=None,
            sort=None):
        """

        :param MarketFilter filter:
        :param int max_results:
        :param list market_projection:
        :param MarketSort sort:
        :param str locale:
        """
        filter = filter or models.MarketFilter()
        return self.make_api_request(
            'Sports',
            'listMarketCatalogue',
            utils.get_kwargs(locals()),
            model=models.MarketCatalogue,
        )
Exemple #32
0
    def get_account_statement(
            self, locale=None, from_record=None, record_count=None,
            item_date_range=None, include_item=None, wallet=None):
        """Get account statement.

        :param str locale: The language to be used where applicable
        :param int from_record: Specifies the first record that will be returned
        :param int record_count: Specifies the maximum number of records to be returned
        :param TimeRange item_date_range: Return items with an itemDate within this date range
        :param IncludeItem include_item: Which items to include
        :param Wallet wallet: Which wallet to return statementItems for
        """
        return self.make_api_request(
            'Account',
            'getAccountStatement',
            utils.get_kwargs(locals()),
            model=models.AccountStatementReport,
        )
Exemple #33
0
    def list_market_book(
            self, market_ids, price_projection=None, order_projection=None,
            match_projection=None, currency_code=None, locale=None):
        """

        :param list market_ids: List of market IDs
        :param PriceProjection price_projection:
        :param OrderProjection order_projection:
        :param MatchProjection match_projection:
        :param str currency_code:
        :param str locale:
        """
        return self.make_api_request(
            'Sports',
            'listMarketBook',
            utils.get_kwargs(locals()),
            model=models.MarketBook,
        )
Exemple #34
0
    def list_market_catalogue(
            self, filter=None, max_results=100, market_projection=None, locale=None,
            sort=None):
        """

        :param MarketFilter filter:
        :param int max_results:
        :param list market_projection:
        :param MarketSort sort:
        :param str locale:
        """
        filter = filter or models.MarketFilter()
        return self.make_api_request(
            'Sports',
            'listMarketCatalogue',
            utils.get_kwargs(locals()),
            model=models.MarketCatalogue,
        )
Exemple #35
0
    def list_market_profit_and_loss(
            self, market_ids, include_settled_bets=False,
            include_bsp_bets=None, net_of_commission=None):
        """Retrieve profit and loss for a given list of markets.

        :param list market_ids: List of markets to calculate profit and loss
        :param bool include_settled_bets: Option to include settled bets
        :param bool include_bsp_bets: Option to include BSP bets
        :param bool net_of_commission: Option to return profit and loss net of
            users current commission rate for this market including any special
            tariffs
        """
        return self.make_api_request(
            'Sports',
            'listMarketProfitAndLoss',
            utils.get_kwargs(locals()),
            model=models.MarketProfitAndLoss,
        )
Exemple #36
0
    def list_market_book(
            self, market_ids, price_projection=None, order_projection=None,
            match_projection=None, currency_code=None, locale=None):
        """

        :param list market_ids: List of market IDs
        :param PriceProjection price_projection:
        :param OrderProjection order_projection:
        :param MatchProjection match_projection:
        :param str currency_code:
        :param str locale:
        """
        return self.make_api_request(
            'Sports',
            'listMarketBook',
            utils.get_kwargs(locals()),
            model=models.MarketBook,
        )
Exemple #37
0
    def get_account_statement(
            self, locale=None, from_record=None, record_count=None,
            item_date_range=None, include_item=None, wallet=None):
        """Get account statement.

        :param str locale: The language to be used where applicable
        :param int from_record: Specifies the first record that will be returned
        :param int record_count: Specifies the maximum number of records to be returned
        :param TimeRange item_date_range: Return items with an itemDate within this date range
        :param IncludeItem include_item: Which items to include
        :param Wallet wallte: Which wallet to return statementItems for
        """
        return self.make_api_request(
            'Account',
            'getAccountStatement',
            utils.get_kwargs(locals()),
            model=models.AccountStatementReport,
        )
Exemple #38
0
    def list_market_profit_and_loss(
            self, market_ids, include_settled_bets=False,
            include_bsp_bets=None, net_of_commission=None):
        """Retrieve profit and loss for a given list of markets.

        :param list market_ids: List of markets to calculate profit and loss
        :param bool include_settled_bets: Option to include settled bets
        :param bool include_bsp_bets: Option to include BSP bets
        :param bool net_of_commission: Option to return profit and loss net of
            users current commission rate for this market including any special
            tariffs
        """
        return self.make_api_request(
            'Sports',
            'listMarketProfitAndLoss',
            utils.get_kwargs(locals()),
            model=models.MarketProfitAndLoss,
        )
Exemple #39
0
def list_market_book(self,
                     market_ids,
                     price_projection=None,
                     order_projection=None,
                     match_projection=None,
                     currency_code=None,
                     locale=None):
    """

    :param list market_ids: List of market IDs
    :param PriceProjection price_projection:
    :param OrderProjection order_projection:
    :param MatchProjection match_projection:
    :param str currency_code:
    :param str locale:

    """
    books = self.make_api_request(
        'listMarketBook',
        utils.get_kwargs(locals()),
        model=None,
    )
    return {
        'market.book':
        market_books(books),
        'runners':
        runners(books),
        'runners.sp':
        runners_sp(books),
        'runners.sp.backStakeTaken':
        runners_prices(books, 'sp', 'backStakeTaken'),
        'runners.sp.layLiabilityTaken':
        runners_prices(books, 'sp', 'layLiabilityTaken'),
        'runners.ex.availableToBack':
        runners_prices(books, 'ex', 'availableToBack'),
        'runners.ex.availableToLay':
        runners_prices(books, 'ex', 'availableToLay'),
        'runners.ex.tradedVolume':
        runners_prices(books, 'ex', 'tradedVolume'),
        'runners.orders':
        runners_orders(books, 'orders'),
        'runners.matches':
        runners_orders(books, 'matches')
    }
def list_market_catalogue(
        self, filter, max_results=100, market_projection=None, locale=None,
        sort=None):
    """

    :param MarketFilter filter:
    :param int max_results:
    :param list market_projection:
    :param MarketSort sort:
    :param str locale:

    """
    markets=self.make_api_request(
        'listMarketCatalogue',
        utils.get_kwargs(locals()),
        model=None,
    )
    return {'description':market_catalogue(markets),
            'runners':market_catalogue_runners(markets)}
def list_current_orders(
        self, bet_ids, market_ids, order_projection, date_range, order_by,
        sort_dir, from_record, record_count):
    """

    :param bet_ids:
    :param market_ids:
    :param order_projection:
    :param date_range:
    :param order_by:
    :param sort_dir:
    :param from_record:
    :param record_count:

    """
    currentOrders=self.make_api_request(
        'listCurrentOrders',
        utils.get_kwargs(locals()),
        model=None,
    )
    return list_orders(currentOrders,'currentOrders')
Exemple #42
0
def list_current_orders(self, bet_ids, market_ids, order_projection,
                        date_range, order_by, sort_dir, from_record,
                        record_count):
    """

    :param bet_ids:
    :param market_ids:
    :param order_projection:
    :param date_range:
    :param order_by:
    :param sort_dir:
    :param from_record:
    :param record_count:

    """
    currentOrders = self.make_api_request(
        'listCurrentOrders',
        utils.get_kwargs(locals()),
        model=None,
    )
    return list_orders(currentOrders, 'currentOrders')
Exemple #43
0
    def list_current_orders(
            self, bet_ids=None, market_ids=None, order_projection=None,
            date_range=None, order_by=None, sort_dir=None, from_record=None,
            record_count=None):
        """

        :param bet_ids:
        :param market_ids:
        :param order_projection:
        :param date_range:
        :param order_by:
        :param sort_dir:
        :param from_record:
        :param record_count:
        """
        return self.make_api_request(
            'Sports',
            'listCurrentOrders',
            utils.get_kwargs(locals()),
            model=models.CurrentOrderSummaryReport,
        )
Exemple #44
0
def list_market_catalogue(self,
                          filter,
                          max_results=100,
                          market_projection=None,
                          locale=None,
                          sort=None):
    """

    :param MarketFilter filter:
    :param int max_results:
    :param list market_projection:
    :param MarketSort sort:
    :param str locale:

    """
    markets = self.make_api_request(
        'listMarketCatalogue',
        utils.get_kwargs(locals()),
        model=None,
    )
    return {
        'description': market_catalogue(markets),
        'runners': market_catalogue_runners(markets)
    }