easy-utils-dev 2.139__py3-none-any.whl → 2.141__py3-none-any.whl

easy_utils_dev/debugger-C-PF4PAMMP.py

@@ -0,0 +1,486 @@
+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)

easy_utils_dev/debugger.py

@@ -128,6 +128,15 @@ class DEBUGGER:
         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 )

easy_utils_dev/temp_memory.py

@@ -17,21 +17,28 @@ class TemporaryMemory :
             sleep(5)
             now = getTimestamp()
             for key, value in list(self.store.items()) :
-                if now >= value.get('removeTimestamp' , 0) :
-                    if value.get('store_deleted_key' , False) :
-                        self.deletions.append(key)
-                    self.delete(key)
+                if value.get('removeTimestamp') :
+                    if now >= value.get('removeTimestamp' , 0) :
+                        if value.get('store_deleted_key' , False) :
+                            self.deletions.append(key)
+                        self.delete(key)
 
     def delete(self , key ) :
-        del self.store[key]
+        try :
+            del self.store[key]
+        except :
+            pass
         gc.collect()
 
-    def get(self , key ) :
-        return self.store.get(key , {}).get('item')
+    def get(self , key , default=None ) :
+        return self.store.get(key , {}).get('item' , default)
 
     def save(self, item , custom_key=None ,auto_destroy_period=60 , store_deleted_key=True) :
         now = getTimestamp()
-        later = getTimestamp(after_seconds=auto_destroy_period)
+        if auto_destroy_period :
+            later = getTimestamp(after_seconds=auto_destroy_period)
+        else :
+            later = None
         if not custom_key :
             custom_key = f"{getTimestamp()}-{generateToken(iter=4)}".upper()
         self.store[custom_key] = {

easy_utils_dev/uiserver.py

@@ -1,18 +1,23 @@
+import copy
+import gc
+import time
 from werkzeug.serving import ThreadedWSGIServer
 from easy_utils_dev.utils import getRandomKey , generateToken , getTimestamp
 from flask_socketio import SocketIO
 from engineio.async_drivers import gevent
-from engineio.async_drivers import threading
 from flask_cors import CORS
 import logging  , os
+from flask import jsonify, request , current_app
 from flask import Flask
 from threading import Thread
+import threading
 from easy_utils_dev.custom_env import cenv
 from easy_utils_dev.utils import kill_thread
 from multiprocessing import Process
 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
 
 def getClassById( id ) :
     return cenv[id]
@@ -23,87 +28,54 @@ def create_ssl(host,output) :
     output: the output locaiton to generate the ssl certificate. it should end with filename without extension
     '''
     return make_ssl_devcert( output , host=host)
-    
-
 
-class Abort :
-    def __init__(self, requestId=getRandomKeysAndStr(50)) :
-        self.requestId = requestId
-        self.result= None
+def clone_request(request):
+    """Return a plain dict clone of Flask request data."""
+    return {
+        "method": request.method,
+        "path": request.path,
+        "url": request.url,
+        "headers": dict(request.headers),
+        "args": request.args.to_dict(flat=False),
+        "form": request.form.to_dict(flat=False),
+        "json": request.get_json(silent=True),
+        "data": request.get_data(),   # raw body bytes
+        "files": {k: v.filename for k, v in request.files.items()},
+        "remote_addr": request.remote_addr,
+        "cookies": request.cookies,
+    }
+
+class AbortRequest :
+    def __init__(self, request ) :
+        self.request = clone_request(request)
+        self.abort_id = None
+        self.abortable = False
         self.thread = None
-        self.aborted=False
-        self.response = {}
-        self.error = False
-        self.message = ''
-        self.starttimestamp = getTimestamp()
-        self.endtimestamp = 0
-        self.kill = self.api_abort
-        pass
-
-
-    def abortable_process(self , operation , args=[] , kwargs={}) :
-        def thread_run() :
-            try :
-                self.result =  operation( *args, **kwargs )
-                self.error = False
-                self.message = ''
-                self.endtimestamp = getTimestamp()
-            except Exception as error :
-                self.error = True
-                self.message = str(error)
-        thread = self.thread = start_thread( target = thread_run )  
-        while thread.is_alive() :
-            sleep(.1)
-            if self.aborted :
-                self.response = {
-                    'message' : 'request aborted.' , 
-                    'id' : self.requestId ,
-                    'status' : 405 , 
-                    'result' : None, 
-                    'error' : self.error , 
-                    'error_message' : '',
-                    'starttimestamp' : self.starttimestamp,
-                    'endtimestamp' : self.endtimestamp,
-                    'aborted' : True,
-                    'threadIsAlive' : thread.is_alive()
-                    } 
-                return self.response
-        sleep(.2)
-        self.response = {
-            'message' : 'request completed.' , 
-            'id' : self.requestId , 
-            'status' : 200 , 
-            'result' : self.result , 
-            'error' : self.error , 
-            'error_message' : self.message ,
-            'starttimestamp' : self.starttimestamp,
-            'endtimestamp' : self.endtimestamp,
-            'aborted' : False ,
-            'threadIsAlive' : thread.is_alive()
-        }
-        return self.response
-
-
-    def api_abort(self) :
-        self.endtimestamp = getTimestamp()
+        self.cache = None
+        self.start_ts = getTimestamp()
+
+    def abort(self) : 
         kill_thread(self.thread)
-        sleep(.5)
-        self.aborted=True
+        self.cache.delete(self.abort_id)
+        try :
+            gc.collect()
+        except :
+            pass
 
 
 class UISERVER :
     def __init__(self ,
-                 id=getRandomKey(n=15),
-                 secretkey=generateToken(),
-                 address='localhost',
-                 port=5312 , 
-                 https=False , 
-                 ssl_crt=None,
-                 ssl_key=None,
-                 template_folder='templates/' ,
-                 static_folder = 'templates/assets'
-                   ,**kwargs
-                ) -> None:
+            id=getRandomKey(n=15),
+            secretkey=generateToken(),
+            address='localhost',
+            port=5312 , 
+            https=False , 
+            ssl_crt=None,
+            ssl_key=None,
+            template_folder='templates/' ,
+            static_folder = 'templates/assets'
+            ,**kwargs
+        ) -> None:
         self.id = id
         self.static_folder = static_folder
         self.app = app = Flask(self.id , template_folder=template_folder  ,  static_folder=self.static_folder )
@@ -116,6 +88,7 @@ class UISERVER :
         self.ssl_key=ssl_key
         self.enable_test_url=True
         self.abort_requests = {}
+        self.abort_base_url = '/request/abort'
         if https :
             self.httpProtocol = 'https'
         else :
@@ -123,18 +96,78 @@ class UISERVER :
         self.socketio = SocketIO(app , cors_allowed_origins="*"  ,async_mode='threading' , engineio_logger=False , always_connect=True ,**kwargs )
         cenv[id] = self
         self.fullAddress = f"{self.httpProtocol}://{self.address}:{self.port}"
+        self.cache = TemporaryMemory()
 
     def update_cert(self , crt, ssl ) :
         self.ssl_crt=crt
         self.ssl_key=ssl
 
+    def register_abortable_request(self , request , abort_id = None ) :
+        path = request.path
+        Abort = AbortRequest(request)
+        if not path.startswith(self.abort_base_url) :
+            if not abort_id :
+                if not request.headers.get('abortid') :
+                    abort_id = getRandomKeysAndStr(n=20)
+                else :
+                    abort_id = request.headers.get('abortid')
+            
+            Abort.abort_id = abort_id
+            current_thread = threading.current_thread()
+            Abort.thread = current_thread
+            Abort.cache = self.cache
+            Abort.start_ts = getTimestamp()
+            self.cache.set( Abort , custom_key=abort_id , auto_destroy_period=120 , store_deleted_key=False )
+        return Abort
+
+    def start_before_request(self) : 
+
+        @self.app.route(f'{self.abort_base_url}/<id>' , methods=['DELETE'])
+        def abort_request(id : str ) :
+            abort : AbortRequest = self.cache.get(id)
+            timestamp = getTimestamp()
+            if abort :
+                abort.abort()
+                for i in range(30) :
+                    th = abort.thread
+                    alive = th.is_alive()
+                    if not alive :
+                        break
+                    time.sleep(.25)
+                return { 'status' : 200 , 'message' : 'Request aborted' , 'abort_timestamp' : timestamp , 'abort_id' : id , 'alive' : alive  , 'url' : abort.request.get('path')}
+            else :
+                return { 'status' : 404 , 'message' : 'Request not found or request is not abortable. Check request headers for abortable flag.'}
+
+        @self.app.before_request
+        def before_request() :
+            abortable = request.headers.get('abortable')
+            if abortable :
+                abort = self.register_abortable_request(request)
+                request.abortable = True
+                request.abort_id = abort.abort_id
+                # check here if async in the headers
+                # if yes . i will trigger the function in thread 
+                # start_tread(#how to get the target function here ? )
+                # now i want to return response to UI { status : 200 , message : 'request now in running bg' , abort_id : abort.abort_id }
+                # the flask function should not be called again
+                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
+                    th = start_thread(target=target_func, args=request.args, kwargs=request.form)
+                    abort.thread = th
+                    return {"status": 200, "message": "Request now in running bg", "abort_id": abort.abort_id} , 200
+
+        @self.app.after_request
+        def after_request(response) :
+            try :
+                if request.abortable :
+                    response.headers['abortid'] = request.abort_id 
+                    response.headers['abortable'] = True
+            except :
+                response.headers['abortable'] = False
+            return response
 
-    def getAbort(self , id ) :
-        result : Abort = self.abort_requests.get(id , Abort)
-        return result
-
-    def updateAbort( self , id , abort ) :
-        self.abort_requests[id] = abort
 
     def getInstance(self) :
         return self.getFlask() , self.getSocketio() , self.getWsgi()
@@ -181,6 +214,7 @@ class UISERVER :
         wsgi_server.serve_forever()
     
     def startUi(self ,daemon , suppress_prints=True) :
+        self.start_before_request()
         self.thread = self.flaskprocess = Thread(target=self.thrStartUi , args=[suppress_prints])
         self.flaskprocess.daemon = False
         self.flaskprocess.start()

easy_utils_dev/wsnoclib.py

@@ -80,6 +80,7 @@ class WSNOCLIB :
         self.refresh_inprogress = False
         self.kafka = kafka
         self.refresh_thread = None
+        self.token_refresh_count = 0
         self.session = WSNOCSession(self)
         if register_atexit :
             atexit.register(self.goodbye)
@@ -135,7 +136,7 @@ class WSNOCLIB :
         data = {
             "grant_type": "client_credentials"
         }
-        r = self.session.post(url = URL , headers=headers , auth=BAuth(self.username, self.password), json=data)
+        r = self.session.post(url = URL , headers=headers , auth=BAuth(self.username, self.password), json=data , retries=5)
         if not r.ok :
             self.logger.debug(f'fail message {r.text}')
             raise Exception(f'Failed to authenticate WSNOC. Return status code : {r.status_code}')
@@ -200,6 +201,7 @@ class WSNOCLIB :
         if self.kafka.enable_auto_refresh :
             self.renewSubscription()
         self.kafka.refresh_inprogress = False
+        self.token_refresh_count += 1
         self.runAutoRefreshThread()
 
     def kafka_connect( self , 
@@ -704,17 +706,18 @@ class WSNOCSession(requests.Session):
         self._wsnoc = wsnoc
         self.verify = False
         self.retries = 0
+        self.debug_this_request = False
         self.skip_hold_for_token_refresh = False
         
     def rebuild_auth(self, prepared_request, response):
         return
 
-    def hold_for_token_refresh(self, url) :
+    def hold_for_token_refresh(self, url=None) :
         while self._wsnoc.refresh_inprogress :
-            self._wsnoc.logger.debug(f'Waiting for token refresh. {url}')
-            sleep(.1)
+            self._wsnoc.logger.info(f'Waiting for token refresh. {url if url else "No URL"}')
+            sleep(.5)
 
-    def request(self, method, url , retries=0 , skip_hold_for_token_refresh=False , **kwargs):
+    def request(self, method, url , retries=0 , skip_hold_for_token_refresh=False , debug_this_request=False , **kwargs):
         self._wsnoc.logger.debug(f'[{method}] : {url}')
         if not skip_hold_for_token_refresh :
             self.hold_for_token_refresh(url)
@@ -726,12 +729,21 @@ class WSNOCSession(requests.Session):
                 request_headers['Authorization'] = token
         kwargs['headers'] = request_headers
         request = super().request(method, url, **kwargs  )
+        if debug_this_request :
+            self._wsnoc.logger.info(f'''
+                [DEBUG] [{method}] : {url}
+                [DEBUG] Headers: {request_headers}
+                [DEBUG] Body: {kwargs.get('data' , {})}
+                [DEBUG] Response: {request.text}
+                [DEBUG] OK: {request.ok}
+                [DEBUG] Method: {request.request.method}
+            ''')
         for i in range(retries) :
             if request.ok :
                 break
             if not request.ok :
                 sleep(1)
-                self.hold_for_token_refresh()
+                self.hold_for_token_refresh(url)
                 request = super().request(method, url, **kwargs )
                 self._wsnoc.logger.debug(f'[Try-{i}] [{method}] : {url}- {request.status_code}')
         self._wsnoc.logger.info(f'[{method}] : {url} - [{request.status_code}]')

{easy_utils_dev-2.139.dist-info → easy_utils_dev-2.141.dist-info}/METADATA

@@ -1,21 +1,23 @@
-Metadata-Version: 2.1
-Name: easy-utils-dev
-Version: 2.139
+Metadata-Version: 2.4
+Name: easy_utils_dev
+Version: 2.141
 Keywords: python3
 Classifier: Programming Language :: Python :: 3
 Requires-Dist: psutil
 Requires-Dist: ping3
 Requires-Dist: flask
-Requires-Dist: flask-cors
+Requires-Dist: flask_cors
 Requires-Dist: xmltodict
 Requires-Dist: paramiko
 Requires-Dist: oracledb
 Requires-Dist: requests
-Requires-Dist: flask-socketio
+Requires-Dist: flask_socketio
 Requires-Dist: python-dotenv
 Requires-Dist: gevent
 Requires-Dist: pyzipper
 Requires-Dist: pyjwt
 Requires-Dist: authlib
 Requires-Dist: kafka-python
-
+Dynamic: classifier
+Dynamic: keywords
+Dynamic: requires-dist

{easy_utils_dev-2.139.dist-info → easy_utils_dev-2.141.dist-info}/RECORD

@@ -8,7 +8,8 @@ easy_utils_dev/brevosmtp.py,sha256=A5n13MnVQnDuSjYQ91-MLftmqfg3VQ-36Zqw9OtoTB4,3
 easy_utils_dev/check_license.py,sha256=C8vKXwaduoF3FSuDJ-J_j5jStNNyUdS-mOdLNfsCjmc,4825
 easy_utils_dev/cplib.py,sha256=TPCFNQh4jYSGsm_CrMdivmD3G5B1rprco2O4B0BSnzo,19570
 easy_utils_dev/custom_env.py,sha256=vxrjikpSNJlKfoBE-ef88UExlpXucUe-HcwHMn3gfB0,1510
-easy_utils_dev/debugger.py,sha256=Oz4WcT59FbHouTpprslocljDvevFdmP9hc_zNRVmSdE,18318
+easy_utils_dev/debugger-C-PF4PAMMP.py,sha256=5GmZU1l9R3CSZVIGff-l-gYaf-imJGSGTsh-cxNz6og,18637
+easy_utils_dev/debugger.py,sha256=5GmZU1l9R3CSZVIGff-l-gYaf-imJGSGTsh-cxNz6og,18637
 easy_utils_dev/easy_oracle.py,sha256=Jyc3HSl6eyLayjS8NoE4GOaf8otQlonR5_qOg2h1DjE,2157
 easy_utils_dev/encryptor.py,sha256=f5Zjn0DGtXCyhldpVnBtfcTb4h4Wp0eQPHusEYwIags,1512
 easy_utils_dev/ept.py,sha256=X-Z0_XCNfKK1TxQZquPMBqo3ZuxnK4TvWAYPnBUMlPI,25363
@@ -23,15 +24,15 @@ easy_utils_dev/openid_server.py,sha256=_odeg6omuizSUEJLtbAVn2PnG9vkcUAQ7rU3K5yXk
 easy_utils_dev/optics_utils.py,sha256=G-hFX2iiUCSJjk7BICBRGvVoDq0IBONLZSjagoB5FMg,964
 easy_utils_dev/require_auth.py,sha256=UsYAxfLX5wda6hd0nfLR_tl0bGQ4DYIpaTowsYSku-E,881
 easy_utils_dev/simple_sqlite.py,sha256=J-mcTUnHmAn0eCPD8j-WEoA19uzHRXJ4YRJsyx9B-do,13113
-easy_utils_dev/temp_memory.py,sha256=gfC-izYw8Sg1DD5iOdL8R5-fdB5RK0qkXZie9WmFjPA,1431
-easy_utils_dev/uiserver.py,sha256=d9jImwgSURMH4MIU4Zkro2b20cAbuV8rO_If42FVyZ4,6826
+easy_utils_dev/temp_memory.py,sha256=0Dx_vNUSFQRMtJZNT8tUZXubcG7T6jxevw2WYuGmVe8,1658
+easy_utils_dev/uiserver.py,sha256=zR-3DCo2FUF6Z7vpnzrKuWUl1MC0TparS8_LEDOyuuc,8886
 easy_utils_dev/utils.py,sha256=BmVnbxc336c6WTeDFcEHN6Mavt7fJrIEyK4GXODV3gI,13345
 easy_utils_dev/winserviceapi.py,sha256=2ZP6jaSt1-5vEJYXqwBhwX-1-eQ3V3YzntsoOoko2cw,18804
-easy_utils_dev/wsnoclib.py,sha256=25sjxutCAOHHGaK7-t1owNq9fV29BHFK1Dox08SZdFg,32876
+easy_utils_dev/wsnoclib.py,sha256=kqkOkiafXnrIgdlV__3uyrAoqxG5dmIHnwqm0EkwS2U,33457
 easy_utils_dev/wsselib.py,sha256=YweScnoAAH_t29EeIjBpkQ6HtX0Rp9mQudRsRce2SE8,7920
 easy_utils_dev/ept_sql/create_dirs.sql,sha256=KWfX-Nc6lvr_BC-P6O97NE0idoPW4GNKUKUCgonJhto,3508
 easy_utils_dev/ept_sql/create_ept_tables.sql,sha256=WDHyIyeReV8_QaYBPIpSy-lto3OKvZtex1tWs-FPURQ,67737
-easy_utils_dev-2.139.dist-info/METADATA,sha256=-C0ualpFQyudh54KYQSws8PVDWoPXSme1Bd8FZNA3-E,510
-easy_utils_dev-2.139.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-easy_utils_dev-2.139.dist-info/top_level.txt,sha256=7vBsrpq7NmilkdU3YUvfd5iVDNBaT07u_-ut4F7zc7A,15
-easy_utils_dev-2.139.dist-info/RECORD,,
+easy_utils_dev-2.141.dist-info/METADATA,sha256=dvjJ7N765oLyHIafIY7Q6mh53jjxqeJlLS7vjiSEUxg,572
+easy_utils_dev-2.141.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+easy_utils_dev-2.141.dist-info/top_level.txt,sha256=7vBsrpq7NmilkdU3YUvfd5iVDNBaT07u_-ut4F7zc7A,15
+easy_utils_dev-2.141.dist-info/RECORD,,

{easy_utils_dev-2.139.dist-info → easy_utils_dev-2.141.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.45.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any