Merge pull request #2 from luisrx7/dev

add Strats and better view of strats results

Author: luisrx7

README.md

@@ -49,12 +49,38 @@ To set up and use AviatorStratChecker, follow these simple steps:
    ```
 
 
-5. **Execute the script:**
+5. **Execute the script to start gathering live results:**
    ```bash
    python main.py
    ```
 
 
+
+
+## To test Strategies
+
+1. **Edit the file strats/custom_strats.py to add your strategies:**
+   ```python
+   class ExampleStrat(Strat):
+
+    def on_win(self):
+        super().on_win()
+
+        self.bet = self.base_bet * 1.5
+
+    def on_lose(self):
+        super().on_lose()
+        
+        self.bet = self.base_bet
+   ```
+
+2. **Edit the checker.py script to test your new strat**
+
+3. **Run the checker.py script to test your strat:**
+   ```bash
+   python checker.py
+   ```
+
 ## Contributing
 We welcome contributions! If you encounter any issues or have suggestions, please open an issue or submit a pull request.
 

checker.py

@@ -1,28 +1,96 @@
-from strats.custom_strats import MartingaleStrat
 
+from strats.custom_strats import MartingaleStrat, AntiMartingaleStrat, DAlembertStrat, ParoliStrat, one_3_2_6Strat
 from stratchecker.stratchecker import Strat_checker
 
 import logging
 
-logging.basicConfig(level=logging.INFO)
+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():
-    strat = MartingaleStrat("Martingale",
-                            start_balance=25,
-                            base_bet=0.1,
-                            max_bet=1,
-                            multiplier=2,
-                            max_bets=5 )
-    print(strat.describe())
-
-    strat_checker = Strat_checker(strat, "results1.txt")
-    strat_checker.read_results()
-    strat_checker.run()
-    print(strat.balance)
+    slices = []
+    strats = []
+    
+    strats.append(MartingaleStrat("Martingale",
+                            start_balance=start_balance,
+                            base_bet=base_bet,
+                            max_bet=max_bet,
+                            multiplier=multiplier,
+                            max_bets=max_bets ))
+    
+    
+    strats.append(AntiMartingaleStrat("AntiMartingale",
+                            start_balance=start_balance,
+                            base_bet=base_bet,
+                            max_bet=max_bet,
+                            multiplier=multiplier,
+                            max_bets=max_bets ))
+    
+    strats.append(DAlembertStrat("DAlembert",
+                            start_balance=start_balance,
+                            base_bet=base_bet,
+                            max_bet=max_bet,
+                            multiplier=multiplier,
+                            max_bets=max_bets ))
+    
+    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 ))
+      
+    
+    results = read_results("results.txt")
+    slices = Strat_checker.slice_results(count=5,max_bets=max_bets,results_length=len(results))
+    
+    strat_runners = []
+    for strat in strats:
+        strat_runners.append(Strat_checker(strat, results, slices=slices))
+    
+
+    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

@@ -1,40 +1,106 @@
 from strats.strats import Strat
+from strats.exceptions import MaxBetsReached, InsufficientFunds
 
 import logging
 
+import random
+from rich import print
 
 logger = logging.getLogger(__name__)
 
 
 
 class Strat_checker():
-    def __init__(self, strat:Strat, results_filename:str) -> None:
+    def __init__(self, strat:Strat, results, slices=[]) -> None:
         self.strat = strat
-        self.results_filename = results_filename
-
-    
-    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()
-
+        self.slices = slices
+        self.strat_reports = []
+        self.results = results
 
 
+    
 
+    @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 indexes
+        '''
+        slices = []
+        for i in range(count):
+            #get random start index
+            start_index = random.randint(0,results_length-max_bets)
+            
+            #get random end index
+            end_index = start_index+max_bets
+                        
+            slices.append((start_index,end_index))
+        
+        return slices
+    
+        
+        
+    
+    
+    
 
-    def run(self):
-        self.strat.on_game_start()
+    def report(self):
+        print(f"\nStrategy: {self.strat.description}")
+        for report in self.strat_reports:
+            print(report)            
 
-        for result in self.results:
-            self.strat.gamble()
-            self.strat.calculate_bet(result)
+    
+    def get_slices(self):
+        return self.slices
+    
+    def set_slices(self,slices):
+        self.slices = slices
+    
 
+    def run(self,count:int=1,random_slice:bool=True):
+        '''
+        run the strat count times
+        if random_slice is True, slice the results in a random places 
+        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)
+        
+        
+        if len(self.slices) == 0:
+            #if no slices are defined, generate count slices
+            self.slices = self.slice_results(self.strat.max_bets,count)
+        
+            
+        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()
+                    self.strat.calculate_bet(result)
+                    
+            except MaxBetsReached or InsufficientFunds:
+                pass
 
+            except Exception as e:
+                logging.error(e)
+            
+            finally:
+                self.strat_reports.append(self.strat.report() + f"slice: {self.slices[i]}")
+                
+
+