Enhance logging and configuration management

TwitchChannelPointsMiner/TwitchChannelPointsMiner.py

@@ -494,19 +494,30 @@ class TwitchChannelPointsMiner:
                     self.streamers[streamer_index].channel_points
                     - self.original_streamers[streamer_index]
                 )
-                
+
                 from colorama import Fore
-                streamer_highlight = Fore.YELLOW
-                
+                # TODO FIX Color256Palette error IF IMPORTED NOTHING IS BEING PRINTED IN CONSOLE THAT USED Color256Palette COLORS
+                class Color256Palette:
+                    GREEN = "\033[38;5;46m"
+                    RED = "\033[38;5;196m"
+                    RESET = "\033[0m"
+
                 streamer_gain = (
-                    f"{streamer_highlight}{self.streamers[streamer_index]}{Fore.RESET}, Total Points Gained: {_millify(gained)}"
-                    if Settings.logger.less
-                    else f"{streamer_highlight}{repr(self.streamers[streamer_index])}{Fore.RESET}, Total Points Gained (after farming - before farming): {_millify(gained)}"
+                    (
+                        f"{self.streamers[streamer_index]}, Total Points "
+                        f"{'Gained:'+Color256Palette.GREEN+' +' if gained >= 0 else 'Lost:'+Color256Palette.RED+' -'}"
+                        f"{_millify(abs(gained))}{Fore.RESET}"
+                    )
+                    if Settings.logger.smart
+                    else (
+                        f"{Fore.YELLOW}{self.streamers[streamer_index]}{Fore.RESET}, Total Points Gained: {_millify(gained)}"
+                        if Settings.logger.less
+                        else f"{Fore.YELLOW}{repr(self.streamers[streamer_index])}{Fore.RESET}, Total Points Gained (after farming - before farming): {_millify(gained)}"
+                    )
                 )
-                
-                indent = ' ' * 25
-                streamer_history = '\n'.join(f"{indent}{history}" for history in self.streamers[streamer_index].print_history().split('; ')) 
-                
+
+                streamer_history = '\n'.join(f"{' ' * 25}{history}" for history in self.streamers[streamer_index].print_history().split('; '))
+
                 logger.info(
                     f"{streamer_gain}\n{streamer_history}",
                     extra={"emoji": ":moneybag:"},

TwitchChannelPointsMiner/__init__.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-__version__ = "2.0.2"
+__version__ = "2.0.3"
 from .TwitchChannelPointsMiner import TwitchChannelPointsMiner
 
 __all__ = [

TwitchChannelPointsMiner/classes/entities/EventPrediction.py

@@ -49,7 +49,7 @@ class EventPrediction(object):
     def __str__(self):
         return (
             f"EventPrediction: {self.streamer} - {self.title}"
-            if Settings.logger.less
+            if Settings.logger.less or Settings.logger.smart
             else self.__repr__()
         )
 

TwitchChannelPointsMiner/logger.py

@@ -196,7 +196,7 @@ class GlobalFormatter(logging.Formatter):
 
         if self.settings.emoji is False:
             if "\u2192" in record.msg:
-                record.msg = record.msg.replace("\u2192", "-->")
+                record.msg = record.msg.replace("\u2192", "->")
 
             # With the update of Stream class, the Stream Title may contain emoji
             # Full remove using a method from utils.

TwitchChannelPointsMiner/utils.py

@@ -147,7 +147,7 @@ def set_default_settings(settings, defaults):
     return 0 if char == "A" else 1'''
 
 
-def internet_connection_available(host="8.8.8.8", port=53, timeout=3):
+def internet_connection_available(host="142.250.179.142", port=443, timeout=3):
     try:
         socket.setdefaulttimeout(timeout)
         socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect((host, port))

main.py

@@ -18,6 +18,8 @@ while True:
         from TwitchChannelPointsMiner import TwitchChannelPointsMiner
         from TwitchChannelPointsMiner.classes.Settings import FollowersOrder
         from TwitchChannelPointsMiner.logger import LoggerSettings
+        from TwitchChannelPointsMiner.classes.entities.Streamer import StreamerSettings
+        from TwitchChannelPointsMiner.classes.entities.Bet import Strategy, BetSettings, Condition, OutcomeKeys, FilterCondition, DelayMode
         break
     except ImportError:
         if strikes >= 3:
@@ -27,14 +29,45 @@ while True:
 
 def load_or_create_config(file_path):
     default_config = {
-        "username": "",
-        "password": "",
-        "streamers": []
+        "username": "your-twitch-username",
+        "password": "your-twitch-password (Optional)",
+        "smart_logging": True,
+        "disable_ssl_cert_verification": False,
+        "show_seconds": False,
+        "claim_drops_startup": True,
+        "claim_drops": True,
+        "betting(make_predictions)": True,
+        "follow_raid": True,
+        "emojis": True,
+        "disable_ssl_cert_verification": False,
+        "save_logs": False,
+        "show_username_in_console": False,
+        "streamers": [],
+        "bet": {
+            "strategy": "SMART",
+            "percentage": 5,
+            "percentage_gap": 20,
+            "max_points": 50000,
+            "stealth_mode": True,
+            "delay_mode": "FROM_END",
+            "delay": 6,
+            "minimum_points": 20000,
+        }
     }
 
     if os.path.exists(file_path):
         with open(file_path, 'r') as file:
             config = json.load(file)
+
+        updated = False
+        for key, value in default_config.items():
+            if key not in config:
+                config[key] = value
+                updated = True
+        if updated:
+            with open(file_path, 'w') as file:
+                json.dump(config, file, indent=4)
+
     else:
         with open(file_path, 'w') as file:
             json.dump(default_config, file, indent=4)
@@ -44,21 +77,63 @@ def load_or_create_config(file_path):
 
 def main():
     config = load_or_create_config("config.json")
+    bet_settings = config.get("bet", {})
+
+    newStrategy = None
+    for strategy in Strategy:
+        if bet_settings.get(strategy.name):
+            newStrategy = strategy
+            break
+    else:
+        newStrategy = Strategy.SMART
+
+    newDelayMode = None
+    for delay_mode in DelayMode:
+        if bet_settings.get(delay_mode.name):
+            newDelayMode = delay_mode
+            break
+    else:
+        newDelayMode = DelayMode.FROM_END
 
     try:
         logger_settings = LoggerSettings(
-            save=True,
+            save=config.get("save_logs", False),
             console_level=logging.INFO,
             file_level=logging.DEBUG,
-            emoji=True,
-            smart=True,
-            show_seconds=False
+            emoji=config.get("emojis", True),
+            smart=config.get("smart_logging", True),
+            show_seconds=config.get("show_seconds", False),
+            console_username=config.get("show_username_in_console", False)
+        )
+
+        streamer_settings = StreamerSettings(
+            make_predictions=config.get("betting(make_predictions)", True),
+            follow_raid=config.get("follow_raid", True),
+            claim_drops=config.get("claim_drops", True),
+            bet=BetSettings(
+                strategy=newStrategy,
+                percentage=bet_settings.get("percentage"),
+                percentage_gap=bet_settings.get("percentage_gap"),
+                max_points=bet_settings.get("max_points"),
+                stealth_mode=bet_settings.get("stealth_mode"),
+                delay_mode=newDelayMode,
+                delay=bet_settings.get("delay"),
+                minimum_points=bet_settings.get("minimum_points"),
+                filter_condition=FilterCondition(
+                    by=OutcomeKeys.TOTAL_USERS,
+                    where=Condition.LTE,
+                    value=800
+                )
+            )
         )
 
         twitch_miner = TwitchChannelPointsMiner(
             username=config.get("username", ""),
             password=config.get("password", ""),
-            logger_settings=logger_settings
+            claim_drops_startup=config.get("claim_drops_startup", True),
+            disable_ssl_cert_verification=config.get("disable_ssl_cert_verification", False),
+            logger_settings=logger_settings,
+            streamer_settings=streamer_settings
         )
 
         streamers = config.get("streamers", [])