added more strats

Author: luisrx7

checker.py

@@ -1,53 +1,96 @@
-from strats.custom_strats import MartingaleStrat, AntiMartingaleStrat
 
+from strats.custom_strats import MartingaleStrat, AntiMartingaleStrat, DAlembertStrat, ParoliStrat, one_3_2_6Strat
 from stratchecker.stratchecker import Strat_checker
 
 import logging
 
-logging.basicConfig(format='%(message)s', level=logging.INFO, datefmt='%m/%d/%Y %I:%M:%S')
+logging.basicConfig(format='%(message)s', level=logging.ERROR, datefmt='%m/%d/%Y %I:%M:%S')
 
 
 #set logger format 
 
 
 
+start_balance=25
+base_bet=0.1
+max_bet=1
+multiplier=2
+max_bets=1000
+runs_per_strat=5
+
+
+
+def read_results(results_filename):
+    #read file
+    with open(results_filename) as f:
+        file_content = f.readlines()
+
+    #remove timestamp and newline
+    results = [float(x.split(",")[1].replace("\n","")) for x in file_content]
+    #invert list
+    results.reverse()
+
+    return results
+
+
+
 def main():
     slices = []
+    strats = []
 
-    strat = MartingaleStrat("Martingale",
-                            start_balance=25,
-                            base_bet=0.1,
-                            max_bet=1,
-                            multiplier=2,
-                            max_bets=1000 )
-    print(strat.describe())
+    strats.append(MartingaleStrat("Martingale",
+                            start_balance=start_balance,
+                            base_bet=base_bet,
+                            max_bet=max_bet,
+                            multiplier=multiplier,
+                            max_bets=max_bets ))
 
 
-    strat2 = AntiMartingaleStrat("AntiMartingale",
-                            start_balance=25,
-                            base_bet=0.1,
-                            max_bet=1,
-                            multiplier=2,
-                            max_bets=1000 )
+    strats.append(AntiMartingaleStrat("AntiMartingale",
+                            start_balance=start_balance,
+                            base_bet=base_bet,
+                            max_bet=max_bet,
+                            multiplier=multiplier,
+                            max_bets=max_bets ))
 
-
-    
-    strat_checker = Strat_checker(strat, "results.txt")
-    strat_checker.read_results()
-    strat_checker.run(count=5,random_slice=True)
-    slices = strat_checker.get_slices()
+    strats.append(DAlembertStrat("DAlembert",
+                            start_balance=start_balance,
+                            base_bet=base_bet,
+                            max_bet=max_bet,
+                            multiplier=multiplier,
+                            max_bets=max_bets ))
 
-    strat_checker2 = Strat_checker(strat2, "results.txt")
-    strat_checker2.read_results()
-    strat_checker2.set_slices(slices)
-    strat_checker2.run(count=5,random_slice=False)
-     
+    strats.append(ParoliStrat("Paroli",
+                            start_balance=start_balance,
+                            base_bet=base_bet,
+                            max_bet=max_bet,
+                            multiplier=multiplier,
+                            max_bets=max_bets ))
+    strats.append(one_3_2_6Strat("one_3_2_6",
+                            start_balance=start_balance,
+                            base_bet=base_bet,
+                            max_bet=max_bet,
+                            multiplier=multiplier,
+                            max_bets=max_bets ))
+      
 
-    strat_checker.report()
+    results = read_results("results.txt")
+    slices = Strat_checker.slice_results(count=5,max_bets=max_bets,results_length=len(results))
 
-    strat_checker2.report()
+    strat_runners = []
+    for strat in strats:
+        strat_runners.append(Strat_checker(strat, results, slices=slices))
 
-    print(strat.balance)
+
+    for strat_runner in strat_runners:
+        strat_runner.run(count=runs_per_strat)
+        
+
+
+    for strat_runner in strat_runners:
+        strat_runner.report()
+
+
 
 
 

stratchecker/stratchecker.py

@@ -4,43 +4,37 @@
 import logging
 
 import random
+from rich import print
 
 logger = logging.getLogger(__name__)
 
 
 
 class Strat_checker():
-    def __init__(self, strat:Strat, results_filename:str, slices=[]) -> None:
+    def __init__(self, strat:Strat, results, slices=[]) -> None:
         self.strat = strat
-        self.results_filename = results_filename
         self.slices = slices
+        self.strat_reports = []
+        self.results = results
 
-    
-    def read_results(self):
-        #read file
-        with open(self.results_filename) as f:
-            file_content = f.readlines()
-
-        #remove timestamp and newline
-        self.results = [float(x.split(",")[1].replace("\n","")) for x in file_content]
-        #invert list
-        self.results.reverse()
 
+    
 
-    def slice_results(self,max_length,count):
+    @staticmethod
+    def slice_results(count,max_bets,results_length):
 
         '''
         slice results in a random place making sure that
         the max_length of the slice is not exceeded
-        return the slice
+        return the slice indexes
         '''
         slices = []
         for i in range(count):
             #get random start index
-            start_index = random.randint(0,len(self.results)-max_length)
+            start_index = random.randint(0,results_length-max_bets)
 
             #get random end index
-            end_index = start_index+max_length
+            end_index = start_index+max_bets
 
             slices.append((start_index,end_index))
 
@@ -72,14 +66,15 @@ def run(self,count:int=1,random_slice:bool=True):
         count must be greater than 1 if random_slice is True
         '''
 
+
+        
         if random_slice is True and count == 1:
             logging.warning("random_slice is True and count is 1, setting random_slice to False")
             random_slice = False
 
         if self.strat.max_bets > len(self.results):
             logging.warning(f"max bets {self.strat.max_bets} is greater than the number of results {len(self.results)}, setting max bets to {len(self.results)}")
             self.strat.max_bets = len(self.results)
-        self.strat_reports = []
 
 
         if len(self.slices) == 0:
@@ -89,9 +84,7 @@ def run(self,count:int=1,random_slice:bool=True):
 
         for i in range(count):
 
-                    
             self.strat.reset()
-            
             try:
                 for result in self.results[self.slices[i][0]:self.slices[i][1]]:
                     self.strat.gamble()

strats/custom_strats.py

@@ -45,4 +45,116 @@ def on_lose(self):
         super().on_lose()
 
         self.bet = self.base_bet
-        
+        
+
+class DAlembertStrat(Strat):
+    '''
+    D Alembert System | Increase your bet amount by 1 unit whenever you lose and decrease by 1 unit if you win.
+    1 unit = base_bet
+    '''
+    def __init__(self,description,start_balance, base_bet, max_bet, multiplier ,max_bets):
+        super().__init__(description,start_balance, base_bet, max_bet, multiplier ,max_bets)
+        
+
+    def on_win(self):
+        super().on_win()
+        if self.bet > self.base_bet:
+            self.bet = self.bet - self.base_bet
+        else:
+            self.bet = self.base_bet
+
+    def on_lose(self):
+        super().on_lose()
+        
+        if self.bet < self.max_bet:
+            self.bet = self.bet + self.base_bet
+        else:
+            self.bet = self.max_bet
+
+class ParoliStrat(Strat):
+    '''
+    Paroli System | Increase your bet amount by 1 unit whenever you win. If you win three times in a row, go back to the start and bet 1 unit again.    1 unit = base_bet
+    '''
+    def __init__(self,description,start_balance, base_bet, max_bet, multiplier ,max_bets):
+        super().__init__(description,start_balance, base_bet, max_bet, multiplier ,max_bets)
+        
+        
+    def on_win(self):
+        super().on_win()
+
+        if self.win_streak == 3:
+            self.bet = self.base_bet
+        else:
+            self.bet = self.bet + self.base_bet
+
+    def on_lose(self):
+        super().on_lose()
+        
+        self.bet = self.base_bet
+
+class OscarGrindStrat(Strat):
+    '''
+    Oscar Grind | Increase your bet amount by 1 unit after each win. Keep it the same when you lose. When you end up with at least 1 unit of profit, go back to the start and bet 1 unit again.    
+    1 unit = base_bet
+
+    needs work
+    '''
+    
+    def __init__(self,description,start_balance, base_bet, max_bet, multiplier ,max_bets):
+        super().__init__(description,start_balance, base_bet, max_bet, multiplier ,max_bets)
+        
+        
+    def on_win(self):
+        super().on_win()
+
+        self.bet = self.bet + self.base_bet
+
+    def on_lose(self):
+        super().on_lose()
+        
+        self.bet = self.base_bet
+
+class FibonacciStrat(Strat):
+    '''
+    Fibonacci | Increase your bet amount by the sum of the previous two bets after each loss. When you win, go back two numbers in the sequence and bet that amount.    
+    1 unit = base_bet   
+
+    needs work
+
+    '''
+    
+    def __init__(self,description,start_balance, base_bet, max_bet, multiplier ,max_bets):
+        super().__init__(description,start_balance, base_bet, max_bet, multiplier ,max_bets)
+        
+        
+    def on_win(self):
+        super().on_win()
+
+        self.bet = self.bet + self.base_bet
+
+    def on_lose(self):
+        super().on_lose()
+        
+        self.bet = self.base_bet
+
+
+class one_3_2_6Strat(Strat):
+    '''
+    1-3-2-6 System | Start by betting 1 unit, followed by 3 units, 2 units, and 6 units, before starting again, but only move up the sequence when you win.
+    1 unit = base_bet
+
+    not sure if this is implemented correctly
+    '''
+    
+    def __init__(self,description,start_balance, base_bet, max_bet, multiplier ,max_bets):
+        super().__init__(description,start_balance, base_bet, max_bet, multiplier ,max_bets)
+        self.bet_sequence = [1,3,2,6]       
+        
+    def on_win(self):
+        super().on_win()
+        self.bet = self.bet_sequence[self.win_streak % len(self.bet_sequence)] * self.base_bet
+
+    def on_lose(self):
+        super().on_lose()
+        
+        self.bet = self.base_bet