betfair 0.0.18 → 0.0.20

data/examples/simplebot.log

@@ -0,0 +1,4 @@
+# Logfile created on 2012-03-28 17:07:58 +0800 by logger.rb/25413
+I, [2012-03-28 17:08:20#2169]  INFO -- : username - ["GBR"] - INVALID_USERNAME_OR_PASSWORD - OK - exiting
+I, [2012-03-28 17:08:53#2309]  INFO -- : username - ["GBR"] - INVALID_USERNAME_OR_PASSWORD - OK - exiting
+I, [2012-03-28 17:09:24#2317]  INFO -- : username - ["GBR"] - INVALID_USERNAME_OR_PASSWORD - OK - exiting

data/examples/simplebot/README.md

@@ -0,0 +1,51 @@
+Credits
+-------
+Big thanks to wotsisname from the Betfair forums, as per [this post](http://forum.bdp.betfair.com/showthread.php?p=6117#post6117)
+and [from here](http://bespokebots.com/betfair_bots.php).
+
+I pretty much copied this directly from his Python bot.
+
+
+Notes on what it does
+---------------------
+
+Logs in to the Betfair UK exchange and monitors the session, logging in again if the session is closed.
+
+Calls GetAllMarkets and obtains all UK horse racing markets starting in the next 24 hours.
+
+Filters the markets so we end up with a list of win only, single winner, odds markets with BSP disabled. 
+
+This should leave us with only the UK win markets.
+
+The strategy checks each market for existing bets. 
+If we have no matched or unmatched bets, the bot will check for any runner available to back at 2.00 or less. 
+If runners are found, it places a LAY bet at the current back price +1 tick/pip to a £2 stake. 
+This places your bet at the front of the queue or gets matched immediately, depending on the back/lay price spread of the market. 
+The bots maximum lay price is 2.01.
+
+The bot does NOT have a GUI and is intended to be run on a dedicated PC/Mac or a remote VPS.
+ 
+Therefore, you should only use this code if you are comfortable with programming in Ruby AND running your scripts from a command line. 
+The API library has been thoroughly tested in a Linux production environment and uptimes exceeding 6 months are easily achieved with suitable error handling.
+
+
+Disclaimer
+----------
+Please note that the bot strategy has NOT been tested beyond basic functionality, so I have no idea whether or not it is profitable long term. 
+The free source code is only intended as an example, so it is up to YOU decide whether or not to use it. 
+Please don't blame me if you lose money using the bot.
+
+
+Daemonize
+----------
+
+`ruby daemonize.rb run` will test the script and output to the logfile location specified
+
+or 
+
+`ruby daemonize.rb start` will start the script as a daemon  and output to the logfile location specified in the background with a pidfile in the root folder
+
+
+Monit
+-----
+See the monit.conf for an example on how to keep this alive on a server.

data/examples/simplebot/daemonize.rb

@@ -0,0 +1,8 @@
+require 'daemons'
+
+simplebot = { :app_name   => 'simplebot',
+              :dir_mode   => :script,
+              :dir        => './'
+             }
+             
+Daemons.run('./simplebot.rb', simplebot)

data/examples/simplebot/monit.conf

@@ -0,0 +1,6 @@
+check process simplebot
+ with pidfile /home/foo/simplebot/simplebot.pid
+ start program = "/usr/local/rvm/bin/rvm-shell -l -c 'cd /home/foo/simplebot; ruby daemonize.rb start'"
+ stop program =  "/usr/local/rvm/bin/rvm-shell -l -c 'cd /home/foo/simplebot; ruby daemonize.rb stop'"
+ if totalmem is greater than 150 MB for 10 cycles then restart # eating up memory?
+ group simplebot

data/examples/simplebot/simplebot.rb

@@ -0,0 +1,168 @@
+class SimpleBot
+    
+  require 'betfair'
+  require 'date'
+  require 'active_support/core_ext' # Only really need this one to do the easy datetime stuff such as 30.minutes.from_now.utc
+  
+  LOG_PATH            = '/Users/lukebyrne/Sites/current/betfair/examples/simplebot/simplebot.log' # Absolute path to where you want put your log file
+  
+  USERNAME            = 'username'              # BF Usernmae
+  PASSWORD            = 'password'              # BF Password
+  PRODUCT_ID          = 82                      # BF Product ID, Free is 82
+  VENDOR_SOFTWARE_ID  = 0                       
+  LOCATION_ID         = 0
+  IP_ADDRESS          = nil
+  
+  THROTTLE            = 3                      # How many seconds to wait between checking each market
+  BANDWIDTH_SAVER     = 30                      # How long to sleep for if no markets are found
+  
+  EXCHANGE_ID         = 2                       # Exchanges you want to hit up 1 for UK, 2 for AUS
+  SPORTS_IDS          = [7]                     # Array of the sports ids you want
+  LOCALE              = nil                     # What coutry are you in? Dont really use this
+  COUNTRIES           = ['GBR']                 # Array of countries you wish to check for
+  FROM_DATE           = Time.now.utc            # Time you want to start checking from in UTC (which is basically GMT, which is the Betfair API time)
+  TO_DATE             = 30.minutes.from_now.utc # How far out do you want to look for markets
+  
+  MARKET_NAMES_INGORE = ['To Be Placed']        # Array of markets to ignore
+  MARKET_TYPE         = 'O'                     # Not sure what this is
+  MARKET_STATUS       = 'ACTIVE'                # Active market types
+  NUMBER_OF_WINNERS   = 1                       # Only one winner per market
+  BSP_MARKET          = true                     # Starting price market ?
+  IN_PLAY             = 0                     # 0 means not in play, anything above this means in play
+  
+  ODDS                = 2.0                     # Bet on odds below this
+  BET_SIDE            = 'L'                     # What type of bet, B for back and L for Lay
+  BET_AMOUNT          = 2.0                     # Note this needs to be a minimum of $5 if you have an AUS account
+  BET_PIP             = 0.01                    # Place bet one pip above the ODDS I am checking for, ie this will try and lay 2.0 pounds on odds of 2.01
+  
+  BF                  = Betfair::API.new        # Initialize BF API methods
+  HELPERS             = Betfair::Helpers.new    # Initialize Helper API methods
+  
+  LOGGER              = Logger.new(LOG_PATH,'daily') # New log file daily  
+  original_formatter  = Logger::Formatter.new 
+  original_formatter.datetime_format = "%Y-%m-%d %H:%M:%S"
+  LOGGER.formatter    = proc { |severity, datetime, progname, msg|
+                          original_formatter.call(severity, datetime, progname, "#{USERNAME} - #{COUNTRIES} - #{msg}")
+                        }
+  
+  def run
+    begin
+      token = login # Get our session token                  
+      if token.success? # Successful login
+        LOGGER.info "Logged in successfully with #{USERNAME}, token returned - #{token}. Fetching Horses from #{COUNTRIES} and looking to lay odds on runners"
+        
+        loop do   
+          token = BF.keep_alive(token)
+          LOGGER.info("Keep alive - #{token}")
+                         
+          LOGGER.info 'Fetching markets'
+          markets = BF.get_all_markets(token, EXCHANGE_ID, SPORTS_IDS, LOCALE, COUNTRIES, FROM_DATE, TO_DATE)     
+          
+          if markets.is_a?(String) and markets != 'API_ERROR - NO_SESSION' # Markets returned correctly           
+            check_markets(token, markets)            
+            #token = nil # Set token here to nil to test the token reset below
+          
+          elsif markets.is_a?(String) and markets == 'API_ERROR - NO_SESSION' # Session token has expired, try and get a new one                                    
+            token = reset_login
+            
+          else # No markets
+            LOGGER.info "No markets found, going to sleep for #{BANDWIDTH_SAVER} seconds"
+            sleep BANDWIDTH_SAVER                     
+          end
+          
+        end # End loop
+        
+      else # No login token returned
+        LOGGER.info "#{token.to_s} - exiting"
+      end 
+       
+    rescue
+       LOGGER.info "Error - SimpleBot.run - #{$!.message}\n(#{$!.class})\n#{$!.backtrace}\n"
+    end    
+  end
+  
+  def login 
+    BF.login(USERNAME, PASSWORD, PRODUCT_ID, VENDOR_SOFTWARE_ID, LOCATION_ID, IP_ADDRESS)
+  end
+  
+  def reset_login
+    token = login             
+    if token.success? 
+      LOGGER.info "Session token has expired, got a new one - #{token}"  
+    else  
+      LOGGER.info "Session token has expired, trying to get a new one returned #{token.to_s}"
+    end
+    return token
+  end
+  
+  def check_markets(token, markets)
+    markets_hash = []
+    HELPERS.split_markets_string(markets).each do |m| 
+      m[:time_to_start] = m[:event_date] - FROM_DATE.to_f # Sort the hash by the time - NEED TO DO THIS
+      markets_hash << m if !m[:market_id].nil? and !MARKET_NAMES_INGORE.include?(m[:market_name]) and MARKET_TYPE == m[:market_type] and MARKET_STATUS == m[:market_status] and NUMBER_OF_WINNERS == m[:number_of_winners] and IN_PLAY == m[:bet_delay] #and BSP_MARKET == m[:bsp_market]                  
+    end
+    
+    if markets_hash.count > 0
+      markets_hash.each { |m| check_runners(token, EXCHANGE_ID, m[:market_id]); sleep THROTTLE; } 
+    else
+      LOGGER.info "Markets found but none we are interested in, going to sleep for #{BANDWIDTH_SAVER} seconds"
+      sleep BANDWIDTH_SAVER
+    end
+  end
+  
+  def check_runners(token, exchange_id, market_id)
+    LOGGER.info "#{market_id} - Checking prices for market_id"
+    prices = HELPERS.prices_complete( BF.get_market_prices_compressed(token, exchange_id, market_id) )            
+    # Need to recheck whether the market is ACTIVE and not IN_PLAY, this time from what gets returned from prices compressed
+    if MARKET_STATUS == prices[:market_status].to_s and IN_PLAY == prices[:in_play_delay]
+      bets_placed = bets_already_placed(token, exchange_id, market_id)  
+      LOGGER.info "#{market_id} - #{bets_placed.count} bets already placed for market_id"  
+      
+      bets = []
+      prices.each do |k,v|        
+        bets << { selection_id: v[:selection_id], b1: v[:b1] } if k.is_a?(Numeric) and !bets_placed.include?(v[:selection_id]) and v[:b1] <= ODDS.to_f       
+      end
+      
+      if bets.count > 0
+        place_bets(token, exchange_id, market_id, bets) 
+      else
+        LOGGER.info "#{market_id} - Bets have already been placed for runners AND/OR no more runners to lay below odds of #{ODDS}"
+      end
+      
+    else
+      LOGGER.info "#{market_id} - Is currently either not Active or is In Play"
+    end
+  end
+  
+  def bets_already_placed(token, exchange_id, market_id)
+    begin
+      LOGGER.info "#{market_id} - Checking existing bets for market_id"
+      bets_placed = []
+      foo = BF.get_mu_bets(token, exchange_id, market_id)       
+      if foo != 'NO_RESULTS - OK'
+        foo = [foo] if foo.is_a?(Hash) # If there is only one bet placed on a market then it returns a Hash, not an Array, needs to be an Array so we can loop it       
+        foo.each { |bet| bets_placed << bet[:selection_id].to_i }         
+      end
+      return bets_placed
+    rescue
+       LOGGER.info "Error - SimpleBot.bets_already_placed - #{$!.message}\n(#{$!.class})\n#{$!.backtrace}\n"
+    end
+  end
+  
+  def place_bets(token, exchange_id, market_id, bets)
+    begin
+      foo = []
+      bets.each do |bet|
+        foo <<  { market_id: market_id, runner_id: bet[:selection_id], bet_type: BET_SIDE, price: bet[:b1]+BET_PIP.to_f, size: BET_AMOUNT, asian_line_id: 0, 
+                  bet_category_type: 'E', bet_peristence_type: 'NONE', bsp_liability: 0 }   
+      end   
+      bets = BF.place_multiple_bets(token, exchange_id, foo)    
+      LOGGER.info "#{market_id} - Placing bets #{bets}"
+    rescue
+      LOGGER.info "Error - SimpleBot.run - #{$!.message}\n(#{$!.class})\n#{$!.backtrace}\n"
+    end
+  end
+  
+end
+SimpleBot.new.run
+

data/lib/betfair/api.rb

@@ -28,7 +28,7 @@ module Betfair
     end # module Failure
 
 
-    ## API METHODS
+    ## Bet Placement API METHODS
     #
 
     def place_bet(session_token, exchange_id, market_id, selection_id, bet_type, price, size)		
@@ -77,8 +77,51 @@ module Betfair
                          :bets => { 'PlaceBets' => bf_bets } )
 
       return response.maybe_result( :bet_results, :place_bets_result )
+    end      
+    
+    def update_bet(session_token, exchange_id, bet_id, new_bet_persitence_type, new_price, new_size, old_bet_persitance_type, old_price, old_size)
+       bf_bet = { 
+          :betId                  => bet_id, 
+          :newBetPersistenceType  => new_bet_persitence_type, 
+          :newPrice               => new_price, 
+          :newSize                => new_size, 
+          :oldBetPersistenceType  => old_bet_persitance_type, 
+          :oldPrice               => old_price, 
+          :oldSize                => old_size
+        }
+
+        response = exchange(exchange_id).
+          session_request( session_token,
+                           :updateBets, 
+                           :update_bets_response,
+                           :bets => { 'UpdateBets' => [bf_bet] } )
+
+        return response.maybe_result( :bet_results, :update_bets_result )
     end
-          
+
+    def update_multiple_bets(session_token, exchange_id, bets)
+      bf_bets = []
+      bets.each do |bet|
+        bf_bets << { 
+          :betId                  => bet[:bet_id], 
+          :newBetPersistenceType  => bet[:new_bet_persitence_type], 
+          :newPrice               => bet[:new_price], 
+          :newSize                => bet[:new_size], 
+          :oldBetPersistenceType  => bet[:old_bet_persitance_type], 
+          :oldPrice               => bet[:old_price], 
+          :oldSize                => bet[:old_size] 
+        }
+      end
+
+      response = exchange(exchange_id).
+        session_request( session_token,
+                         :updateBets, 
+                         :update_bets_response,
+                         :bets => { 'UpdateBets' => bf_bets } )
+
+      return response.maybe_result( :bet_results, :update_bets_result )     
+    end
+    
     def cancel_bet(session_token, exchange_id, bet_id)
       bf_bet = { :betId => bet_id }
 
@@ -90,8 +133,7 @@ module Betfair
       
       return response.maybe_result( :bet_results, :cancel_bets_result )
     end
-    
-    
+        
     def cancel_multiple_bets(session_token, exchange_id, bets)
       bf_bets = []
       bets.each { |bet_id| bf_bets << { :betId => bet_id } }
@@ -106,19 +148,29 @@ module Betfair
     end
     
     def cancel_bet_by_market(session_token, exchange_id, market_id)
-    
+      raise 'Service not available in product id of 82'
     end
     
-    def cancel_bets_by_market(session_token, exchange_id, market_ids)
-      
-    end
+    ## Read-Only Betting API METHODS
+    #
     
-    def update_bet(session_token, exchange_id, market_id)
-      
-    end
+    def get_mu_bets( session_token, exchange_id, market_id = 0, bet_status = 'MU', start_record = 0, record_count = 200, sort_order = 'ASC', order_by =  'PLACED_DATE') #, bet_ids = nil, , exclude_last_second = nil, matched_since = nil
+      response = exchange(exchange_id).
+        session_request( session_token, 
+                         :getMUBets, 
+                         :get_mu_bets_response,
+                         #:betIds => bet_ids,
+                         :betStatus => bet_status,
+                         #:excludeLastSecond => exclude_last_second,
+                         :marketId => market_id,
+                         #:matchedSince => matched_since,
+                         :orderBy => order_by,
+                         :recordCount => record_count,
+                         :sortOrder => sort_order,
+                         :startRecord => start_record
+                         )
 
-    def update_bets(session_token, exchange_id, market_ids)
-      
+      return response.maybe_result( :bets, :mu_bet )
     end
     
     
@@ -173,34 +225,13 @@ module Betfair
 
 
     def get_account_funds( session_token, exchange_id )
-      response = exchange( exchange_id ).
+      response = exchange(exchange_id).
         session_request( session_token, 
                          :getAccountFunds, 
                          :get_account_funds_response )
 
       return response.maybe_result
     end
-    
-
-    def get_mu_bets( session_token, exchange_id, market_id = 0, bet_status = 'MU', start_record = 0, record_count = 200, sort_order = 'ASC', order_by =  'PLACED_DATE') #, bet_ids = nil, , exclude_last_second = nil, matched_since = nil
-      response = exchange( exchange_id ).
-        session_request( session_token, 
-                         :getMUBets, 
-                         :get_mu_bets_response,
-                         #:betIds => bet_ids,
-                         :betStatus => bet_status,
-                         #:excludeLastSecond => exclude_last_second,
-                         :marketId => market_id,
-                         #:matchedSince => matched_since,
-                         :orderBy => order_by,
-                         :recordCount => record_count,
-                         :sortOrder => sort_order,
-                         :startRecord => start_record
-                         )
-
-      return response.maybe_result( :bets, :mu_bet )
-    end
-
 
     def login(username, password, product_id, vendor_software_id, location_id, ip_address)
       response = @global_service.request( :login, 
@@ -215,12 +246,27 @@ module Betfair
       return response.maybe_result( :header, :session_token )
     end
     
-    def keep_alive
+    ## General API METHODS
+    #
+    
+    def keep_alive(session_token)
+      response = @global_service.
+        session_request( session_token,
+                         :keep_alive, 
+                         :keep_alive_response )
       
+      # Need to do the old school way of checking as the keep_alive response doesn't return a minorErrorCode, so fails
+      error_code = response[:header][:error_code]     
+      return error_code == 'OK' ? response[:header][:session_token] : error_code
+      #return response.maybe_result( :header, :session_token )
     end
     
-    def logout
-      
+    def logout(session_token)
+      response = @global_service.
+        session_request( session_token,
+                         :logout, 
+                         :logout_response )
+      return response.maybe_result( :header, :session_token )
     end
 
     #
@@ -351,35 +397,63 @@ module Betfair
 
 
   class Helpers  	  	
-
+    
+    ## HELPER METHODS
+    #
+    
     def all_markets(markets)
       market_hash = {}
       markets.gsub! '\:', "\0"
       markets = markets.split ":"
       markets.each do |piece|
         piece.gsub! "\0", '\:'
-        market_hash[piece.split('~')[0].to_i] = { :market_id            => piece.split('~')[0].to_i,
-          :market_name          => piece.split('~')[1].to_s,
-          :market_type          => piece.split('~')[2].to_s,
-          :market_status        => piece.split('~')[3].to_s,
+        foo = piece.split('~')
+        market_hash[foo[0].to_i] = { 
+          :market_id            => foo[0].to_i,
+          :market_name          => foo[1].to_s,
+          :market_type          => foo[2].to_s,
+          :market_status        => foo[3].to_s,
           # bf returns in this case time in Epoch, but in milliseconds
-          :event_date           => Time.at(piece.split('~')[4].to_i/1000),
-          :menu_path            => piece.split('~')[5].to_s,
-          :event_hierarchy      => piece.split('~')[6].to_s,
-          :bet_delay            => piece.split('~')[7].to_s,
-          :exchange_id          => piece.split('~')[8].to_i,
-          :iso3_country_code    => piece.split('~')[9].to_s,
-          # bf returns in this case time in Epoch, but in milliseconds
-          :last_refresh         => Time.at(piece.split('~')[10].to_i/1000),
-          :number_of_runners    => piece.split('~')[11].to_i,
-          :number_of_winners    => piece.split('~')[12].to_i,
-          :total_amount_matched => piece.split('~')[13].to_f,
-          :bsp_market           => piece.split('~')[14] == 'Y' ? true : false,
-          :turning_in_play      => piece.split('~')[15] == 'Y' ? true : false
+          :event_date           => Time.at(foo[4].to_i/1000),
+          :menu_path            => foo[5].to_s,
+          :event_hierarchy      => foo[6].to_s,
+          :bet_delay            => foo[7].to_s,
+          :exchange_id          => foo[8].to_i,
+          :iso3_country_code    => foo[9].to_s,
+          # bf returns in this case time in Epoch, but in milliseconds 
+          :last_refresh         => Time.at(foo[10].to_i/1000),
+          :number_of_runners    => foo[11].to_i,
+          :number_of_winners    => foo[12].to_i,
+          :total_amount_matched => foo[13].to_f,
+          :bsp_market           => foo[14] == 'Y' ? true : false,
+          :turning_in_play      => foo[15] == 'Y' ? true : false
         } 
       end
       return market_hash
     end
+    
+    # Pass in the string returned from the get_all_markets() API call and get back a proper hash
+    # This duplicates the helper above, not sure where this came from one of contributors must have added it.
+    def split_markets_string(string)
+      string_raw = string
+      foo = []
+      if string_raw.is_a?(String)
+        string_raw.split(':').each do |string|
+          bar = string.split('~')
+          
+          bsp_market        = bar[14] == 'Y' ? true : false
+          turning_in_play   = bar[15] == 'Y' ? true : false
+          event_date        = Time.at(bar[4].to_i/1000).utc
+          last_refresh      = Time.at(bar[10].to_i/1000).utc
+          
+          doh = { market_id: bar[0].to_i, market_name: bar[1], market_type: bar[2], market_status: bar[3], event_date: event_date, menu_path: bar[5], event_heirachy: bar[6], 
+                  bet_delay: bar[7].to_i, exchange_id: bar[8].to_i, iso3_country_code: bar[9], last_refresh: last_refresh, number_of_runners: bar[11].to_i, number_of_winners: bar[12].to_i, 
+                  total_amount_matched: bar[13].to_f, bsp_market: bsp_market, turning_in_play: turning_in_play }        
+          foo << doh if !doh[:market_name].nil?
+        end
+      end
+      return foo
+    end
 
     def market_info(details)
       { :exchange_id => nil,
@@ -392,16 +466,6 @@ module Betfair
       }
     end
 
-    def combine(market, prices)
-      market = details(market)            
-      prices = prices(prices)
-      market[:runners].each do |runner|
-        runner.merge!( { :market_id => market[:market_id] } )
-        runner.merge!( { :market_type_id => market[:market_type_id] } )
-        runner.merge!(price_string(prices[runner[:runner_id]]))
-      end
-    end
-
     def details(market)
       runners = []
       market[:runners][:runner].each { |runner| runners << { :runner_id => runner[:selection_id].to_i, :runner_name => runner[:name] } }
@@ -418,6 +482,16 @@ module Betfair
       end
       return price_hash
     end
+    
+    def combine(market, prices)
+      market = details(market)            
+      prices = prices(prices)
+      market[:runners].each do |runner|
+        runner.merge!( { :market_id => market[:market_id] } )
+        runner.merge!( { :market_type_id => market[:market_type_id] } )
+        runner.merge!(price_string(prices[runner[:runner_id]]))
+      end
+    end
 
     ##
     #
@@ -435,37 +509,40 @@ module Betfair
       # parsing first the auxiliary price info
       aux = pieces.first
       aux.gsub! "\0", '\:'
+      foo = aux.split('~')
       aux_hash =   {  
-        :market_id                      => aux.split('~')[0].to_i,
-        :currency                       => aux.split('~')[1].to_s,
-        :market_status                  => aux.split('~')[2].to_s,
-        :in_play_delay                  => aux.split('~')[3].to_i,
-        :number_of_winners              => aux.split('~')[4].to_i,
-        :market_information             => aux.split('~')[5].to_s,
-        :discount_allowed               => aux.split('~')[6] == 'true' ? true : false,
-        :market_base_rate               => aux.split('~')[7].to_s,
-        :refresh_time_in_milliseconds   => aux.split('~')[8].to_i,
-        :removed_runners                => aux.split('~')[9].to_s,
-        :bsp_market                     => aux.split('~')[10] == 'Y' ? true : false
+        :market_id                      => foo[0].to_i,
+        :currency                       => foo[1].to_s,
+        :market_status                  => foo[2].to_s,
+        :in_play_delay                  => foo[3].to_i,
+        :number_of_winners              => foo[4].to_i,
+        :market_information             => foo[5].to_s,
+        :discount_allowed               => foo[6] == 'true' ? true : false,
+        :market_base_rate               => foo[7].to_s,
+        :refresh_time_in_milliseconds   => foo[8].to_i,
+        :removed_runners                => foo[9].to_s,
+        :bsp_market                     => foo[10] == 'Y' ? true : false
       }
 
       # now iterating over the prices excluding the first piece that we already parsed above 
       pieces[1..-1].each do |piece|
         piece.gsub! "\0", '\:'
-
+        
+        bar = piece.split('~')
         # using the selection_id as hash key
-        price_hash_key = piece.split('~')[0].to_i
-
-        price_hash[price_hash_key] = {  :selection_id         => piece.split('~')[0].to_i,
-          :order_index          => piece.split('~')[1].to_i,
-          :total_amount_matched => piece.split('~')[2].to_f,
-          :last_price_matched   => piece.split('~')[3].to_f,
-          :handicap             => piece.split('~')[4].to_f,
-          :reduction_factor     => piece.split('~')[5].to_f,
-          :vacant               => piece.split('~')[6] == 'true' ? true : false,
-          :far_sp_price         => piece.split('~')[7].to_f,
-          :near_sp_price        => piece.split('~')[8].to_f,
-          :actual_sp_price      => piece.split('~')[9].to_f                           
+        price_hash_key = bar[0].to_i
+
+        price_hash[price_hash_key] = {  
+          :selection_id                 => bar[0].to_i,
+          :order_index                  => bar[1].to_i,
+          :total_amount_matched         => bar[2].to_f,
+          :last_price_matched           => bar[3].to_f,
+          :handicap                     => bar[4].to_f,
+          :reduction_factor             => bar[5].to_f,
+          :vacant                       => bar[6] == 'true' ? true : false,
+          :far_sp_price                 => bar[7].to_f,
+          :near_sp_price                => bar[8].to_f,
+          :actual_sp_price              => bar[9].to_f                           
         }
 
         # merge lay and back prices into price_hash
@@ -521,21 +598,6 @@ module Betfair
 
       return price			  		
     end
-
-    # Pass in the string returned from the get_all_markets() API call and get back a proper hash
-    def split_markets_string(markets)
-      foo = []
-      if markets.is_a?(String)
-        markets.split(':').each do |market|
-          bar = market.split('~')
-          doh = { market_id: bar[0].to_i, market_name: bar[1], market_type: bar[2], market_status: bar[3], event_date: bar[4].to_i, menu_path: bar[5], event_heirachy: bar[6], 
-                  bet_delay: bar[7].to_i, exchange_id: bar[8].to_i, iso3_country_code: bar[9], last_refresh: bar[10].to_i, number_of_runners: bar[11].to_i, number_of_winners: bar[12].to_i, 
-                  total_amount_matched: bar[13].to_f, bsp_market: bar[14], turning_in_play: bar[15] }        
-          foo << doh if !doh[:market_name].nil?
-        end
-      end
-      return foo
-    end
     
   end