easy-utils-dev 2.155__tar.gz → 2.157__tar.gz

{easy_utils_dev-2.155 → easy_utils_dev-2.157}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easy_utils_dev
-Version: 2.155
+Version: 2.157
 Keywords: python3
 Classifier: Programming Language :: Python :: 3
 Requires-Dist: psutil

{easy_utils_dev-2.155 → easy_utils_dev-2.157}/easy_utils_dev/debugger.py

@@ -1,7 +1,7 @@
 import logging
 import os
 import shutil
-import  sys
+import  sys , re , random
 from datetime import datetime
 from logging.handlers import RotatingFileHandler
 from .utils import getRandomKey , convert_mb_to_bytes , getTimestamp, mkdirs , start_thread
@@ -33,6 +33,33 @@ def setGlobalDebugLevel(level='info') :
     gEvent.dispatchEvent('update_debug_level')
 
 
+class CensorFilter(logging.Filter):
+    def __init__(self):
+        super().__init__()
+        self.censored_strings = []
+        self.censor_ip = True
+        # Regex for IPv4
+        self.ip_regex = re.compile(r"\b\d{1,3}(?:\.\d{1,3}){3}\b")
+
+    def add_censored_string(self, value):
+        if value:
+            self.censored_strings.append(str(value))
+
+    def filter(self, record):
+        msg = record.getMessage()
+
+        # Replace registered sensitive strings
+        for s in self.censored_strings:
+            x = random.randint(5, 10)
+            msg = msg.replace(s, '*'*x)
+        # Replace IPs
+        if self.censor_ip :
+            msg = self.ip_regex.sub("***.***.***.***", msg)
+        # Overwrite message
+        record.msg = msg
+        record.args = ()
+        return True
+
 class DEBUGGER:
     def __init__(self 
             , name
@@ -45,7 +72,8 @@ class DEBUGGER:
             global_debugger=None,
             disable_log_write=False,
             file_name=None,
-            seperate_files=True
+            seperate_files=True,
+            trust_env_log_path=True
         ):
         env = custom_env()
         setupEnvironment( 'debugger' )
@@ -63,6 +91,7 @@ class DEBUGGER:
         self.create_log_path(homePath, file_name)
         self.fullSyntax=fullSyntax
         self.onScreen= onscreen
+        self.trust_env_log_path = trust_env_log_path
         self.id = id
         self.stream_service = None
         if not env['debugger'].get(name) :
@@ -78,6 +107,9 @@ class DEBUGGER:
         self.global_debugger = global_debugger
         self.isLogWriteDisabled = disable_log_write
         self.type = "CUSTOM_DEBUGGER"
+        self.censor = CensorFilter()
+        console_handler.addFilter(self.censor)
+
         self.seperate_files=seperate_files
         if fullSyntax :
             f = f"[%(asctime)s]-[{self.name}]-[%(levelname)s]: %(message)s"
@@ -118,8 +150,9 @@ class DEBUGGER:
         start_thread(target=self.checks_in_bg)
 
     def create_log_path(self , base_path , logname ) :
+        # print(f"Creating log path : {base_path} {logname}")
         if not base_path :
-            base_path = os.path.join(os.getcwd() , 'debug')
+            base_path = os.getcwd()
         if not logname :
             logname = self.name
         if base_path :
@@ -128,23 +161,6 @@ class DEBUGGER:
             self.filename = logname
             self.lastAbsoluteHomePath = base_path
             self.log_path_with_filename = os.path.join(base_path, f'{logname}.log')
-            # print(f"Filename : {self.filename}")
-        # print(f"Base Home Path : {self.baseHomePath}")
-        # print(f"Log path With Filename : {self.log_path_with_filename}")
-        # print(f"Last Absolute Home Path : {self.lastAbsoluteHomePath}")
-
-    def fix_file_not_found_file_rotation(self) : 
-        for i in range(self.BACKUP_COUNT) :
-            try :
-                file_path = self.homePath + f'.{i}'
-                # print(f"Checking log file path  : {file_path}")
-                if not os.path.exists(file_path) :
-                    with open(file_path, 'a+') as f :
-                        # print(f"Creating log file path  : {file_path}")
-                        f.write('')
-            except :
-                pass
-
 
     def switch_full_syntax(self , toggle) :
         if toggle :
@@ -165,9 +181,10 @@ class DEBUGGER:
         self.console.setFormatter(self.formatter)    
 
     def updateGlobalHomePath(self ) :
+        if not self.trust_env_log_path :
+            return
         if not self.isLogWriteDisabled :
             getFromEnv = self.env.get('debugger_homepath' , None )
-            # print(f"getFromEnv : {getFromEnv}")
             if getFromEnv : 
                 self.create_log_path(getFromEnv, self.filename)
                 self.file_handler_class = self.createRotateFileHandler(self.log_path_with_filename)
@@ -258,7 +275,6 @@ class DEBUGGER:
     
     def checks_in_bg(self) :
         while True :
-            #self.fix_file_not_found_file_rotation()
             if self.env.get('GLOBAL_DEBUGGER_STREAM_SERVICE') :
                 self.addStreamService(socketio=self.env.get('GLOBAL_DEBUGGER_STREAM_SERVICE'))
             if self.env.get('debugger_global_level' , None) : 
@@ -273,7 +289,8 @@ class DEBUGGER:
                     self.logger.error(f'EASY_UTILS_DEBUG_LEVEL ENV must be one of [info,debug,warning,error,critical] | Current Env Variable Is "{EASY_UTILS_DEBUG_LEVEL}". Skipping ')
                 else :
                     self.set_level(EASY_UTILS_DEBUG_LEVEL)
-            self.updateGlobalHomePath()
+            if self.trust_env_log_path :
+                self.updateGlobalHomePath()
             if os.environ.get("EASY_UTILS_ENABLE_PRINT" , '' ).lower() == 'true' :
                 self.enable_print()
             sleep(10)
@@ -314,12 +331,13 @@ class DEBUGGER:
     def changeHomePath( self , path ) :
         def delet_later(lastAbsoluteHomePath) :
             if lastAbsoluteHomePath :
-                sleep(3)
+                sleep(1)
                 try :
                     shutil.rmtree(lastAbsoluteHomePath)
                 except :
                     pass
         start_thread(target=delet_later, args=[self.lastAbsoluteHomePath])
+        sleep(.5)
         self.create_log_path( path , self.filename)
         self.file_handler_class = self.createRotateFileHandler(self.log_path_with_filename)
 

{easy_utils_dev-2.155 → easy_utils_dev-2.157}/easy_utils_dev/ne1830PSS.py

@@ -12,9 +12,23 @@ from easy_utils_dev import exceptions
 
 
 class PSS1830 :
-    def __init__(self , sim=False , debug_name='Auto1830PSS' , auto_enable_tcp_forward=False,file_name=None,debug_home_path=None ) -> None:
+    def __init__(self , 
+    sim=False , 
+    debug_name='Auto1830PSS' , 
+    auto_enable_tcp_forward=False,
+    file_name=None,
+    debug_home_path=None,
+    trust_env_log_path=True,
+    debugger_kwargs={}
+    ) -> None:
         self.port = None
-        self.logger = DEBUGGER(debug_name,file_name=file_name, homePath=debug_home_path)
+        self.trust_env_log_path = trust_env_log_path
+        self.logger = DEBUGGER(
+            debug_name,file_name=file_name, 
+            homePath=debug_home_path,
+            trust_env_log_path=trust_env_log_path,
+            **debugger_kwargs
+        )
         self.connected = False
         self.channel = None
         self.nodeName = None

{easy_utils_dev-2.155 → easy_utils_dev-2.157}/easy_utils_dev/uiserver.py

@@ -1,9 +1,12 @@
 import gc
+import json
 import time
+from flask.ctx import F
 from werkzeug.serving import ThreadedWSGIServer
-from easy_utils_dev.utils import getRandomKey , generateToken , getTimestamp
+from easy_utils_dev.utils import convertTimestampToDate, getRandomKey , generateToken , getTimestamp
 from flask_socketio import SocketIO
 from engineio.async_drivers import gevent
+from engineio.async_drivers import threading as threading_engineio
 from flask_cors import CORS
 import logging  , os
 from flask import jsonify, request , current_app , copy_current_request_context
@@ -18,6 +21,9 @@ from werkzeug.serving import make_ssl_devcert
 from time import sleep
 from easy_utils_dev.utils import start_thread , getRandomKeysAndStr , mkdirs
 from easy_utils_dev.temp_memory import TemporaryMemory
+from easy_utils_dev.debugger import DEBUGGER
+import signal
+import sys
 
 def getClassById( id ) :
     return cenv[id]
@@ -92,6 +98,7 @@ class SocketClientObject :
 
 class UISERVER :
     def __init__(self ,
+            logger : DEBUGGER = None,
             id=getRandomKey(n=15),
             secretkey=generateToken(),
             serve_with_secret_key=False,
@@ -121,6 +128,7 @@ class UISERVER :
         self.bg_requests = {}
         self.socketio_clients = []
         self.abort_base_url = '/request/abort'
+        self.return_exception_as_code_400 = True
         self.request_reply_base_url= '/request/result'
         if https :
             self.httpProtocol = 'https'
@@ -133,6 +141,10 @@ class UISERVER :
         start_thread(target=self.delete_very_old_requests)
         self.secret_key_execlude_urls = []
         self.socketio_rooms = {}
+        self.log_url_requests = True
+        self.logger = logger
+        self.simulate_network_delay = False
+
 
     def update_cert(self , crt, ssl ) :
         self.ssl_crt=crt
@@ -158,6 +170,7 @@ class UISERVER :
 
     def delete_very_old_requests(self) :
         while True :
+            sleep(320)
             now = getTimestamp()
             for key, value in list(self.bg_requests.items()) :
                 value : AbortRequest = value
@@ -165,7 +178,6 @@ class UISERVER :
                     if value.delete_async_request_ts > now :
                         del self.bg_requests[key]
             gc.collect()
-            sleep(320)
 
     def create_room(self , room_id : str , members : list[str] ) :
         self.socketio_rooms[room_id] = members
@@ -197,6 +209,14 @@ class UISERVER :
             else :
                 return { 'status' : 404 , 'message' : 'Request not found or request is not abortable. Check request headers for abortable flag.'}
         
+        @self.app.route(f"/request/traceback/<key>" , methods=['GET'])
+        def get_traceback(key : str ) :
+            traceback = self.cache.get(key)
+            if traceback :
+                return { 'status' : 200 , 'traceback' : traceback.get('traceback') }
+            else :
+                return { 'status' : 404 , 'message' : 'Traceback not found or expired' }
+
         @self.app.route(f'{self.request_reply_base_url}/<id>' , methods=['GET'])
         def get_result_of_async_request(id : str ) :
             request : AbortRequest = self.bg_requests.get(id)
@@ -217,6 +237,10 @@ class UISERVER :
 
         @self.app.before_request
         def before_request() :
+            if self.log_url_requests and self.logger :
+                self.logger.info(f'[{request.method}]: {request.url}'  , source='WebServer')
+
+                
             if (self.serve_with_secret_key) and (request.path not in self.secret_key_execlude_urls) and (request.headers.get('secretkey') != self.secretkey):
                 return jsonify({"error": "Secret key is invalid"}), 401
                         
@@ -257,26 +281,72 @@ class UISERVER :
                 if request.headers.get('async') == 'false' : 
                     target_func = current_app.view_functions.get(request.endpoint)
                     if not target_func:
-                        return jsonify({"error": "Route not found"}), 404
+                        return {"error": "Route not found"}, 404
                     th = start_thread(target=run_async_job_results, args=[target_func , abort ])
                     abort.thread = th
                     self.bg_requests[requestId] = abort
                     return {"status": 200, "message": "Request now in running bg", "abort_id": abort.abort_id} , 200
     
+        if self.return_exception_as_code_400 :
+            @self.app.errorhandler(Exception)
+            def handle_exception(e):
+
+                exc_type, exc_value, exc_traceback = sys.exc_info()
+                key = getRandomKeysAndStr(n=10)
+                tb_last = traceback.extract_tb(exc_traceback)[-1]  # Get last traceback frame
+                # Example: file, line, function, text
+                error_file = tb_last.filename
+                error_line = tb_last.lineno
+                error_func = tb_last.name
+                error_code = tb_last.line
+
+                # Log the full traceback (optional)
+                traceback.print_exc()
+                # Customize the error response
+                t = getTimestamp()
+                response = {
+                    "status" : 400 ,
+                    "key" : key,
+                    "error": str(e),
+                    "message": str(e),
+                    "type": type(e).__name__ ,
+                    "request_full_url" : request.url ,
+                    "request_method" : request.method ,
+                    "endpoint" : request.endpoint ,
+                    "request_path" : request.path ,
+                    "error_file" : os.path.basename(error_file).replace('.py' , ''),
+                    "error_line" : error_line,
+                    "error_func" : error_func,
+                    "error_code" : error_code,
+                    'timestamp' : t ,
+                    "date" : convertTimestampToDate(t) ,
+                    'traceback_url' : f"/request/traceback/{key}"
+                }
+                self.logger.error(f'error: {json.dumps(response , indent=4)}')
+                self.cache.set( custom_key=key , item={**response , 'traceback' : str(traceback.format_exc())} , auto_destroy_period=1800 , store_deleted_key=False )
+                # del response['traceback']
+                return response , 200
 
         @self.app.after_request
         def after_request(response) :
+
+            if self.simulate_network_delay :
+                time.sleep(self.simulate_network_delay)
+
             try :
                 now = getTimestamp()
                 response.headers['internalid'] = request.internalid
                 response.headers['start_ts'] = request.start_ts
                 response.headers['end_ts'] = now
-                response.headers['execution'] = round(now - request.start_ts, 2)
+                x = round(now - request.start_ts, 2)
+                response.headers['execution'] = x
                 if request.abortable :
                     response.headers['abortid'] = request.abort_id 
                     response.headers['abortable'] = True
             except :
                 response.headers['abortable'] = False
+            if self.log_url_requests and self.logger :
+                self.logger.info(f'[{request.method}]: {request.url} - [{response.status_code}] [secs:{x}]'  , source='WebServer')
             return response
 
         # socketio client connected.
@@ -322,12 +392,18 @@ class UISERVER :
         return self.wsgi_server
     
     def shutdownUi(self) :
+        if hasattr(self, 'wsgi_server') and self.wsgi_server:
+            try:
+                self.wsgi_server.shutdown()
+                self.wsgi_server.server_close()
+            except:
+                pass
         kill_thread(self.thread)
-        self.wsgi_server.server_close()
-        self.wsgi_server.shutdown()
 
     def _wait_th(self , t ) :
-        t.join()
+        # t.join()
+        while True :
+            time.sleep(10)
     
 
     def thrStartUi(self , suppress_prints=True) :
@@ -356,15 +432,46 @@ class UISERVER :
         log.setLevel(logging.ERROR)
         wsgi_server.serve_forever()
     
-    def startUi(self ,daemon , suppress_prints=True) :
+    def on_ctrl_c(self , sig=None, frame=None):
+        self.stopUi()
+        pid = os.getpid()
+        os.kill(pid, signal.SIGTERM)
+        sys.exit(0)
+
+
+    def startUi(self , daemon=False , suppress_prints=True , block=False) :
         self.start_before_request()
         self.thread = self.flaskprocess = Thread(target=self.thrStartUi , args=[suppress_prints])
-        self.flaskprocess.daemon = False
+        self.flaskprocess.daemon = daemon
         self.flaskprocess.start()
         start_thread(target=self._wait_th , args=[self.thread] , daemon=daemon)
+        signal.signal(signal.SIGINT, self.on_ctrl_c )
+        if block:
+            self.wait()
         return self.thread
     
+    def wait(self):
+        """
+        Block the main thread to keep it alive for signal handling (Ctrl+C).
+        This allows Ctrl+C to be properly detected. Call this after startUi() 
+        if you want signal handling to work.
+        """
+        try:
+            while self.flaskprocess.is_alive():
+                self.flaskprocess.join(timeout=0.1)
+        except KeyboardInterrupt:
+            if not hasattr(self, '_shutting_down'):
+                self._shutting_down = True
+                self.on_ctrl_c()
+        except SystemExit:
+            # Re-raise SystemExit to allow proper program termination
+            raise
+    
     def stopUi(self) :
+        if hasattr(self, 'wsgi_server') and self.wsgi_server:
+            try:
+                self.wsgi_server.shutdown()
+            except:
+                pass
         kill_thread(self.thread)
-        return True
-    
+        return True

{easy_utils_dev-2.155 → easy_utils_dev-2.157}/easy_utils_dev/wsnoclib.py

@@ -55,7 +55,7 @@ class WSNOCLIB :
         password ,
         debug_level='info', 
         debug_name='wsnoclib' ,
-        debug_homepath='./debug/',
+        debug_homepath='./',
         request_max_count=30,
         tmp_dir = tempfile.gettempdir() ,
         kafka = KafkaConfig(),

{easy_utils_dev-2.155 → easy_utils_dev-2.157}/easy_utils_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easy_utils_dev
-Version: 2.155
+Version: 2.157
 Keywords: python3
 Classifier: Programming Language :: Python :: 3
 Requires-Dist: psutil

{easy_utils_dev-2.155 → easy_utils_dev-2.157}/easy_utils_dev.egg-info/SOURCES.txt

@@ -10,7 +10,6 @@ easy_utils_dev/brevosmtp.py
 easy_utils_dev/check_license.py
 easy_utils_dev/cplib.py
 easy_utils_dev/custom_env.py
-easy_utils_dev/debugger-C-PF4PAMMP.py
 easy_utils_dev/debugger.py
 easy_utils_dev/easy_oracle.py
 easy_utils_dev/encryptor.py

{easy_utils_dev-2.155 → easy_utils_dev-2.157}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-VERSION = '2.155'
+VERSION = '2.157'
 
 # Setting up
 setup(

easy_utils_dev-2.155/easy_utils_dev/debugger-C-PF4PAMMP.py

@@ -1,486 +0,0 @@
-import logging
-import os
-import  sys
-from datetime import datetime
-from logging.handlers import RotatingFileHandler
-from .utils import getRandomKey , convert_mb_to_bytes , getTimestamp , start_thread
-from .custom_env import custom_env , setupEnvironment
-from .Events import EventEmitter
-from threading import Thread
-from time import sleep
-
-gEvent = EventEmitter()
-logging.addLevelName(25, "SCREEN")
-
-def setGlobalHomePath( path ) :
-    env = custom_env()
-    env['debugger_homepath'] = path
-    gEvent.dispatchEvent('update_home_path')
-
-def setGlobalDisableOnScreen(on_screen=False) :
-    env = custom_env()
-    env['debugger_on_screen'] = on_screen
-    if not on_screen :
-        gEvent.dispatchEvent('disable_global_printing')
-    else :
-        gEvent.dispatchEvent('enable_global_printing')
-        
-    
-def setGlobalDebugLevel(level='info') :
-    env = custom_env()
-    env['debugger_global_level'] = level
-    gEvent.dispatchEvent('update_debug_level')
-
-
-class DEBUGGER:
-    def __init__(self 
-            , name
-            , level='info', 
-            fullSyntax=True, 
-            onscreen=True,
-            log_rotation=3,
-            homePath=None,
-            id=getRandomKey(9) , 
-            global_debugger=None,
-            disable_log_write=False,
-            file_name=None,
-            seperate_files=True
-        ):
-        env = custom_env()
-        setupEnvironment( 'debugger' )
-        debugger_on_screen = env.get('debugger_on_screen' , True)
-        env['debugger_on_screen'] = debugger_on_screen
-        self.env = env
-        self.events = gEvent
-        self.debuggerLabel = f"{name}"
-        self.logger = logging.getLogger(self.debuggerLabel)
-        self.set_level(level)
-        self.file_handler_class=None
-        self.LOG_SIZE_THRESHOLD_IN_BYTES = 10 * 1024 * 1024
-        self.BACKUP_COUNT = log_rotation
-        self.homePath = homePath
-        self.lastAbsoluteHomePath= None
-        self.fullSyntax=fullSyntax
-        self.onScreen= onscreen
-        self.id = id
-        self.how_many_times_write= 0
-        self.stream_service = None
-        if not env['debugger'].get(name) :
-            self.console = console_handler = logging.StreamHandler()
-        else :
-            self.console = console_handler = env['debugger'].get(name).console
-        if not self.logger.hasHandlers() :
-            self.logger.addHandler(self.console)
-        self.name = name
-        self.rotate_disabled=False
-        self.isInPyinstaller = False
-        self.log_iterations=0
-        self.log_iterations_threshold = 200
-        self.global_debugger = global_debugger
-        self.isLogWriteDisabled = disable_log_write
-        self.type = "CUSTOM_DEBUGGER"
-        self.seperate_files=seperate_files
-        if fullSyntax :
-            f = f"[%(asctime)s]-[{self.name}]-[%(levelname)s]: %(message)s"
-        else :
-            f = f"[{self.name}]-[%(levelname)s]: %(message)s"
-        self.syntax = f
-        self.formatter = logging.Formatter(f , datefmt='%Y-%m-%d %H:%M:%S' )
-        self.filename = file_name
-        path = self.homepath(homePath)
-        if not env['debugger'].get(name) :
-            console_handler.setFormatter(self.formatter)
-        if not disable_log_write :
-            if not env['debugger'].get(name) :
-                self.file_handler_class = self.createRotateFileHandler(path)
-        if onscreen : 
-            self.enable_print()
-        elif not onscreen : 
-            self.disable_print()
-        self.events.addEventListener('disable_global_printing' , self.disable_print )
-        self.events.addEventListener('enable_global_printing' , self.enable_print )
-        self.events.addEventListener('update_home_path' , self.updateGlobalHomePath )
-        self.events.addEventListener('update_debug_level' , self.updateGlobalSetLevel )
-        if env['debugger'].get(name) :
-            self =  env['debugger'].get(name)
-        else:
-            env['debugger'][id] = self
-            env['debugger'][name] = self
-        if not env.get('debugger_on_screen' , True ) :
-            self.disable_print()
-        if env.get('debugger_on_screen' , True ) :
-            self.enable_print()
-        if os.environ.get("EASY_UTILS_DEBUG_LEVEL") :
-            EASY_UTILS_DEBUG_LEVEL = os.environ.get("EASY_UTILS_DEBUG_LEVEL")
-            if not EASY_UTILS_DEBUG_LEVEL.lower() in ['info' , 'debug' , 'warning' , 'error' , 'critical'] :
-                self.logger.error(f'EASY_UTILS_DEBUG_LEVEL ENV must be one of [info,debug,warning,error,critical] | Current Env Variable Is "{EASY_UTILS_DEBUG_LEVEL}". Skipping ')
-            else :
-                self.set_level(EASY_UTILS_DEBUG_LEVEL)
-        if os.environ.get("EASY_UTILS_ENABLE_PRINT" , '' ).lower() == 'true' :
-            self.enable_print()
-
-    def switch_full_syntax(self , toggle) :
-        if toggle :
-            f = f"[%(asctime)s]-[{self.name}]-[%(levelname)s]: %(message)s"
-        else :
-            f = f"[{self.name}]-[%(levelname)s]: %(message)s"
-        self.syntax = f
-        self.formatter = logging.Formatter(f , datefmt='%Y-%m-%d %H:%M:%S' )
-        self.console.setFormatter(self.formatter)    
-
-    def custom_log_syntax(self , syntax) :
-        '''
-        f"[%(asctime)s]-[{self.name}]-[%(levelname)s]: %(message)s"
-        '''
-        f = syntax
-        self.syntax = f
-        self.formatter = logging.Formatter(f , datefmt='%Y-%m-%d %H:%M:%S' )
-        self.console.setFormatter(self.formatter)    
-
-    def updateGlobalHomePath(self ) :
-        if not self.isLogWriteDisabled :
-            getFromEnv = self.env.get('debugger_homepath' , None )
-            self.homepath(getFromEnv)
-            if getFromEnv : 
-                self.file_handler_class = self.createRotateFileHandler(self.homePath)
-
-    def updateGlobalSetLevel( self ) :
-        self.set_level(self.env['debugger_global_level'])
-
-    def advertiseGlobalDebugLevel(self , level) :
-        setGlobalDebugLevel(level)
-
-    def disable_rotate(self) :
-        self.rotate_disabled = True
-
-    def enable_rotate(self) :
-        self.rotate_disabled = False
-
-    def createRotateFileHandler( self , path ) :
-        old = self.file_handler_class
-        if old :
-            self.logger.removeHandler(old)
-        file_handler = RotatingFileHandler(path ,  maxBytes=self.LOG_SIZE_THRESHOLD_IN_BYTES , backupCount=self.BACKUP_COUNT , delay=True )
-        self.file_handler= file_handler.setFormatter(self.formatter)
-        self.logger.addHandler(file_handler)
-        return file_handler
-
-    def update_log_iterantions_threshold(self,threshold : int ):
-        '''
-        set value when rotation should be checked. when every on_log function called.
-        by default rotation will be checked every 200 on_log function call.
-        '''
-        self.log_iterations_threshold = threshold
-
-    def updateGlobalDebugger(self , logger ) :
-        '''
-        this function pass the log message to other logger to write the same log message to it.
-        logger must be debugger class.
-        '''
-        if logger.type != 'CUSTOM_DEBUGGER' :
-            raise Exception(f'Invalid logger type. must pass debugger class.')
-        self.global_debugger = logger
-
-    def getStreamServiceUrlPath(self) :
-        return self.streampath
-
-    def getStreamService(self) :
-        return self.stream_service
-
-    def isStreamServiceAvailable(self) :
-        if self.stream_service :
-            return True
-        return False
-
-    def addStreamService( self , socketio , streampath='/debugger/stream/log' ) :
-        """
-        This function takes a live socketio server. it emit the log message using default path which is /debugger/stream/log
-        """
-        self.stream_service = socketio
-        self.streampath = streampath
-        
-    def updateLogName( self , name ) :
-        self.name = name
-
-    def disable_log_write(self) :
-        '''
-        this function is used to disable the log write to file. if onScreen is enabled, logs will be displayed only on screen.
-        '''
-        self.isLogWriteDisabled = True
-        if self.file_handler_class :
-            self.logger.removeHandler(self.file_handler_class)
-    
-    def enable_log_write(self) :
-        self.createRotateFileHandler(self.homePath)
-        
-    def manage_file_rotation(self, record ) :
-        handler = self.get_rotate_handler()
-        if handler.shouldRollover(record) :
-            handler.doRollover()
-            self.log_iterations = 0
-
-    def get_rotate_handler(self) :
-        return self.file_handler_class
-            
-    def change_log_size(self, size) -> bool:
-        '''
-        change the size of each log file rotation.
-        default is 10M
-        size should be passed as MB
-        '''
-        size = convert_mb_to_bytes(size)
-        self.LOG_SIZE_THRESHOLD_IN_BYTES = size
-        handler = self.get_rotate_handler()
-        handler.maxBytes = size
-        return True
-
-    
-    def checks_in_bg(self) :
-        while True :
-            if self.env.get('GLOBAL_DEBUGGER_STREAM_SERVICE') :
-                self.addStreamService(socketio=self.env.get('GLOBAL_DEBUGGER_STREAM_SERVICE'))
-            if self.env.get('debugger_global_level' , None) : 
-                self.set_level( level=self.env.get('debugger_global_level') )
-            if not self.env.get('debugger_on_screen' , True ) :
-                self.disable_print()
-            if self.env.get('debugger_on_screen' , True ) :
-                self.enable_print()
-            if os.environ.get("EASY_UTILS_DEBUG_LEVEL") :
-                EASY_UTILS_DEBUG_LEVEL = os.environ.get("EASY_UTILS_DEBUG_LEVEL")
-                if not EASY_UTILS_DEBUG_LEVEL.lower() in ['info' , 'debug' , 'warning' , 'error' , 'critical'] :
-                    self.logger.error(f'EASY_UTILS_DEBUG_LEVEL ENV must be one of [info,debug,warning,error,critical] | Current Env Variable Is "{EASY_UTILS_DEBUG_LEVEL}". Skipping ')
-                else :
-                    self.set_level(EASY_UTILS_DEBUG_LEVEL)
-            self.updateGlobalHomePath()
-            if os.environ.get("EASY_UTILS_ENABLE_PRINT" , '' ).lower() == 'true' :
-                self.enable_print()
-            sleep(5)
-
-    def close(self) :
-        try :
-            logging.shutdown()
-        except :
-            pass
-
-    def homepath(self , path=None ) :
-        env = custom_env()
-        getFromEnv = env.get('debugger_homepath' , None )
-        if getFromEnv is not None :
-            self.homePath = getFromEnv
-        else :
-            if path is not None :
-                if self.homePath and '.log' in str(self.homePath): 
-                    self.lastAbsoluteHomePath= self.homePath
-                self.homePath = path
-            else :
-                self.homePath = os.path.join(os.getcwd() , 'debug')
-        if not os.path.exists( self.homePath ) :
-            try : 
-                os.makedirs( self.homePath )
-            except : 
-                pass
-        if self.filename :
-            self.homePath = os.path.join( self.homePath, f'{self.filename}.log' ) 
-        else :
-            self.homePath = os.path.join( self.homePath, f'{self.name}.log' ) 
-        return self.homePath
-
-    def get_current_levels(self):
-        """
-        Returns a list of log levels that will be printed based on the current logging level.
-        """
-        levels_order = [
-            ('debug', logging.DEBUG),
-            ('info', logging.INFO),
-            ('warning', logging.WARNING),
-            ('error', logging.ERROR),
-            ('critical', logging.CRITICAL),
-        ]
-        # Optional custom level
-        if hasattr(logging, 'SCREEN'):
-            levels_order.append(('screen', logging.SCREEN))
-        current_level = self.logger.level
-        # Return all levels with numeric value >= current_level
-        return [name for name, value in levels_order if value >= current_level]
-
-    def enable_print(self) :
-        self.onScreen = True
-        self.logger.addHandler(self.console)
-
-    def disable_print(self) : 
-        self.onScreen = False
-        self.logger.removeHandler(self.console)
-
-    def changeHomePath( self , path ) :
-        p = self.homepath(path)
-        self.file_handler_class = self.createRotateFileHandler(p)
-        if self.lastAbsoluteHomePath :
-            os.remove(self.lastAbsoluteHomePath)
-
-    def isGlobalDebuggerDefined(self) :
-        if self.global_debugger :
-            return True
-        else :
-            return False
-
-    def set_level(self, level : str):
-        if 'info' in level.lower() : lvl = logging.INFO
-        elif 'warn' in level.lower() : lvl = logging.WARNING
-        elif 'warning' in level.lower() : lvl = logging.WARNING
-        elif 'critical' in level.lower() : lvl = logging.CRITICAL
-        elif 'debug' in level.lower() : lvl = logging.DEBUG
-        elif 'error' in level.lower() : lvl = logging.ERROR
-        elif 'screen' in level.lower() : lvl = logging.SCREEN
-        else : raise ValueError('Unknown level, not one of [info,warn,warning,critical,debug,error,screen]')
-        self.currentDebugLevel = level
-        self.logger.setLevel(lvl)
-
-    def get_current_debug_level(self) :
-        return self.currentDebugLevel
-
-    def get_logger(self) : 
-        return self.logger
-    
-    def before_log(self , message , level) :
-
-        def __call_thread__() :
-            if not level in self.get_current_levels() :
-                return
-            if self.isStreamServiceAvailable() :
-                d = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-                streamUrl = self.getStreamServiceUrlPath()
-                self.stream_service.emit( streamUrl , {
-                    'message' : message ,
-                    'level' : level ,
-                    'msg' : message,
-                    'date' : d ,
-                    'id' : self.id,
-                    'formate' : 'json' ,
-                    'source' : self.name ,
-                    'getTimestamp' : getTimestamp()
-                })
-        try :
-            t= Thread(target=__call_thread__)
-            # t.daemon=True
-            t.start()
-        except :
-            __call_thread__()
-            
-        params = {
-                'screen' : True  ,
-                'file': True
-            }
-        if self.onScreen and self.env['debugger_on_screen'] == True :
-            params['screen'] = True
-        else :
-            params['screen'] = False
-        return params
-        
-
-    def info(self, message , external_debugger=None,source=None):
-        def __call__(message) :
-            if source :
-                message = f'[{source}]-{message}'
-            self.before_log(message , 'info')
-            self.logger.info(message)
-            if self.isGlobalDebuggerDefined() : 
-                self.global_debugger.info(message)
-            if external_debugger :
-                external_debugger.info(message)
-        try :
-            r=Thread(target=__call__,args=[message])
-            r.daemon=True
-            r.start()
-            r.join()
-        except :
-            __call__(message)
-
-    def debug(self, message , external_debugger=None,source=None):
-        def __call__(message) :
-            if source :
-                message = f'[{source}]-{message}'
-            self.before_log(message , 'debug')
-            self.logger.debug(message)
-            if self.isGlobalDebuggerDefined() : 
-                self.global_debugger.debug(message)
-            if external_debugger :
-                external_debugger.debug(message)
-        try :
-            r=Thread(target=__call__,args=[message])
-            r.daemon=True
-            r.start()
-            r.join()
-        except :
-            __call__(message)
-
-    def warning(self, message , external_debugger=None,source=None):
-        def __call__(message) :
-            if source :
-                message = f'[{source}]-{message}'
-            self.before_log(message , 'warning')
-            self.logger.warning(message)
-            if self.isGlobalDebuggerDefined() : 
-                self.global_debugger.warning(message)
-            if external_debugger :
-                external_debugger.warning(message)
-        try :
-            r=Thread(target=__call__,args=[message])
-            r.daemon=True
-            r.start()
-            r.join()
-        except :
-            __call__(message)
-
-    def error(self, message,external_debugger=None,source=None):
-        def __call__(message) :
-            if source :
-                message = f'[{source}]-{message}'
-            self.before_log(message , 'error')
-            self.logger.error(message)
-            if self.isGlobalDebuggerDefined() : 
-                self.global_debugger.error(message)
-            if external_debugger :
-                external_debugger.error(message)
-        try :
-            r=Thread(target=__call__,args=[message])
-            r.daemon=True
-            r.start()
-            r.join()
-        except :
-            __call__(message)
-
-    def critical(self, message,external_debugger=None,source=None):
-        def __call__() :
-            if source :
-                message = f'[{source}]-{message}'
-            self.before_log(message , 'critical')
-            self.logger.critical(message)
-            if self.isGlobalDebuggerDefined() : 
-                self.global_debugger.critical(message)
-            if external_debugger :
-                external_debugger.critical(message)
-        try :
-            r=Thread(target=__call__,args=[message])
-            r.daemon=True
-            r.start()
-            r.join()
-        except :
-            __call__(message)
-
-    def screen(self, message,external_debugger=None,source=None):
-        def __call__() :
-            if source :
-                message = f'[{source}]-{message}'
-            self.before_log(message , 'critical')
-            print(f"{self.syntax}")
-            if self.isGlobalDebuggerDefined() : 
-                self.global_debugger.critical(message)
-            if external_debugger :
-                external_debugger.critical(message)
-        try :
-            r=Thread(target=__call__,args=[message])
-            r.daemon=True
-            r.start()
-            r.join()
-        except :
-            __call__(message)