easy-utils-dev 2.172__tar.gz → 2.174__tar.gz

{easy_utils_dev-2.172 → easy_utils_dev-2.174}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easy_utils_dev
-Version: 2.172
+Version: 2.174
 Keywords: python3
 Classifier: Programming Language :: Python :: 3
 Requires-Dist: psutil
@@ -19,6 +19,8 @@ Requires-Dist: pyzipper
 Requires-Dist: pyjwt
 Requires-Dist: authlib
 Requires-Dist: kafka-python
+Requires-Dist: cachetools
+Requires-Dist: js2py
 Dynamic: classifier
 Dynamic: keywords
 Dynamic: requires-dist

easy_utils_dev-2.174/easy_utils_dev/KeycloakAuthExtension.py

@@ -0,0 +1,178 @@
+# decorators.py
+from functools import wraps
+from flask import request
+from authlib.jose import jwt, JsonWebKey
+import requests , time , os , json
+from cachetools import TTLCache, cached
+from easy_utils_dev.utils import start_thread
+from easy_utils_dev.debugger import DEBUGGER
+from easy_utils_dev.utils import getTimestamp
+
+class Permissions :
+
+    cache = TTLCache(maxsize=128, ttl=1800)
+
+    def __init__(
+            self, 
+            home , 
+            keycloak_url ,
+            webserver ,
+            redirect_url = None ,
+            home_url = None,
+            realm="lrm",
+            **kwargs
+        ):
+        '''
+        home : the home page of the application
+        keycloak_url : the keycloak url . like http://localhost:8080
+        webserver : the webserver object
+        redirect_url : the redirect url
+        home_url : the home url
+        '''
+        self.logger = DEBUGGER(
+            name='WebServerAuth',
+            homePath=home
+        )
+        self.keycloak_url = keycloak_url
+        self.session = requests.Session()
+        self.redirect_url = redirect_url
+        self.home = home
+        self.home_url = home_url
+        self.webserver= webserver
+        self.token_refreshed_times = 5
+        self.admin_user = 'admin'
+        self.admin_password="admin"
+        self.client_secret = "yS92obzbpbk36UPsJx4lMx9EtNujkqDk"
+        self.realm = realm
+        self._thread_login_started = False
+        self.KEYCLOACKACCESSTOKEN = None
+        self.KEYCLOACKREFRESHTOKEN = None
+        self.KEYCLOACKBEARERTOKEN = None
+        start_thread(target=self._thread_login)
+
+
+    def _admin_login(self) :
+        self.logger.info("Admin login process has started")
+        self.logger.debug("Logging in as Keycloak admin ...")
+        url = f"{self.keycloak_url}/realms/master/protocol/openid-connect/token"
+        payload=f'grant_type=password&client_id=admin-cli&username={self.admin_user}&password={self.admin_password}&client_secret={self.client_secret}&scope=openid profile'
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        }
+        response = requests.request("POST", url, headers=headers, data=payload)
+        self.logger.debug(f"Admin login response status: [{response.status_code}]")
+        if response.ok :
+            self.logger.debug("Admin login successful")
+            return response.json()['access_token'] , response.json()['refresh_token']
+        self.logger.error(f"Admin login failed: {response.text}")
+        raise Exception(f"Login Failure status [{response.status_code}] error={response.text}")
+
+    def _thread_login(self) :
+            self.logger.info("Auto login/refresh process has initialized")
+            sleep_period = 1800
+            while True :
+                self.logger.debug("Auto login process is running now ...")
+                if self.token_refreshed_times >= 5 :
+                    self.KEYCLOACKACCESSTOKEN , self.KEYCLOACKREFRESHTOKEN = self._admin_login()
+                    self.KEYCLOACKBEARERTOKEN = f"Bearer {self.KEYCLOACKACCESSTOKEN}"
+                    self.token_refreshed_times = 0
+                    os.environ.setdefault('KEYCLOACKACCESSTOKEN' , self.KEYCLOACKACCESSTOKEN)
+                    os.environ.setdefault('KEYCLOACKREFRESHTOKEN' , self.KEYCLOACKREFRESHTOKEN)
+                    os.environ.setdefault('KEYCLOACKBEARERTOKEN' , self.KEYCLOACKBEARERTOKEN)
+                    time.sleep(sleep_period)
+                    continue
+                data = {
+                    "client_id": 'admin-cli',
+                    "grant_type": "refresh_token",
+                    "refresh_token": self.KEYCLOACKREFRESHTOKEN,
+                    'client_secret' : self.client_secret
+                }
+                url = f"{self.keycloak_url}/realms/master/protocol/openid-connect/token"
+                resp = requests.post(url, data=data)
+                self.logger.info(f"Admin token refreshed status [{resp.status_code}]")
+                self.KEYCLOACKACCESSTOKEN = resp.json()['access_token']
+                self.KEYCLOACKBEARERTOKEN = f"Bearer {self.KEYCLOACKACCESSTOKEN}"
+                self.KEYCLOACKREFRESHTOKEN = resp.json()['refresh_token']
+                os.environ.setdefault('KEYCLOACKACCESSTOKEN' , self.KEYCLOACKACCESSTOKEN)
+                os.environ.setdefault('KEYCLOACKREFRESHTOKEN' , self.KEYCLOACKREFRESHTOKEN)
+                os.environ.setdefault('KEYCLOACKBEARERTOKEN' , self.KEYCLOACKBEARERTOKEN)
+                self.token_refreshed_times += 1
+                time.sleep(sleep_period)
+            
+    def get_jwk_set(self):
+        self.logger.debug(f"Getting JWK set for realm {self.realm}")
+        jwks_url = f"{self.keycloak_url}/realms/{self.realm}/protocol/openid-connect/certs"
+        resp = requests.get(jwks_url)
+        self.logger.debug(f'JWK.Cert.Response text: [{resp.text}]')
+        resp.raise_for_status()
+        self.logger.debug(f"JWK set for realm {self.realm} retrieved successfully")
+        return JsonWebKey.import_key_set(resp.json())
+        
+
+    def extract_token(self , token):
+        self.logger.debug(f'Extracting token for {token}')
+        jwks = self.get_jwk_set()
+        self.logger.debug(f'JWKS key is {jwks}')
+        claims = jwt.decode(token, key=jwks)
+        self.logger.debug(f'Extracted claims: {json.dumps(claims , indent=4)}')
+        return claims
+
+    def get_user_info(self , claims) :
+        now = getTimestamp()
+        if now > claims['exp'] :
+            return False
+        return True
+
+    def require_roles(self , *allowed_roles):
+        def decorator(fn):
+            @wraps(fn)
+            def wrapper(*args, **kwargs):
+                self.webserver.logger.debug(f"Checking roles for function: {fn.__name__}")
+                auth = request.headers.get("Authorization", "")
+                if not auth.startswith("Bearer "):
+                    self.webserver.logger.debug("No Bearer token found in Authorization header")
+                    return self.webserver.Response.unauthorized(message='Authorization failed' , err="no bearer token found in Authorization header" , home_url=self.home_url , redirect_url=self.redirect_url)
+                token = auth.split(" ")[1]
+                claims = self.extract_token(token)
+                self.logger.debug(f"Extracted claims: {claims}")
+                if not claims:
+                    self.webserver.logger.debug(f'Invalid or expired token. will ask client to redirect to "{self.redirect_url}"')
+                    return self.webserver.Response.unauthorized(message='Invalid or expired token' , err="invalid or expired token" , home_url=self.home_url , redirect_url=self.redirect_url)
+                user_roles = claims.get("roles", [])
+                if not any(role in user_roles for role in allowed_roles):
+                    self.webserver.logger.debug(f'Insufficient permissions. will ask client to redirect to "{self.redirect_url}"')
+                    return self.webserver.Response.unauthorized(message='Insufficient permissions' , err="insufficient permissions" , home_url=self.home_url , redirect_url=self.redirect_url)
+                # Inject user info into request context
+                request.user_info = claims
+                self.webserver.logger.debug(f"Access granted for {fn.__name__} with roles: {user_roles}")
+                return fn(*args, **kwargs)
+            return wrapper
+        return decorator
+    
+    def check_access(self):
+        def decorator(fn):
+            @wraps(fn)
+            def wrapper(*args, **kwargs):
+                self.webserver.logger.debug(f"Checking access for function: {fn.__name__}")
+                auth = request.headers.get("Authorization", "")
+                email = request.headers.get("email", "")
+                if not auth.startswith("Bearer "):
+                    self.webserver.logger.debug("No Bearer token found in Authorization header")
+                    return self.webserver.Response.unauthorized(message='Authorization failed' , err="no bearer token found in Authorization header" , home_url=self.home_url , redirect_url=self.redirect_url)
+                token = auth.split(" ")[1]
+                claims = self.extract_token(token)  
+                if not claims :
+                    self.webserver.logger.debug("Invalid or expired token. will ask client to redirect to \"{self.redirect_url}\"")
+                    return self.webserver.Response.unauthorized(message='Invalid or expired token' , err="invalid or expired token" , home_url=self.home_url , redirect_url=self.redirect_url)
+                valid = self.get_user_info(claims)
+                if not valid :
+                    self.webserver.logger.debug("User info validation failed for token")
+                    return self.webserver.Response.unauthorized(message='Authorization failed' , err="user info validation failed for token" , home_url=self.home_url , redirect_url=self.redirect_url)
+                # Inject user info into request context
+                request.user_info = claims
+                self.webserver.logger.debug(f"Access granted for email={email}")
+                return fn(*args, **kwargs)
+            return wrapper
+        return decorator
+
+    

{easy_utils_dev-2.172 → easy_utils_dev-2.174}/easy_utils_dev/debugger.py

@@ -89,6 +89,7 @@ class DEBUGGER:
         self.LOG_SIZE_THRESHOLD_IN_BYTES = 10 * 1024 * 1024
         self.BACKUP_COUNT = log_rotation
         self.name = name
+        self._home = homePath
         self.create_log_path(homePath, file_name)
         self.fullSyntax=fullSyntax
         self.onScreen= onscreen

{easy_utils_dev-2.172 → easy_utils_dev-2.174}/easy_utils_dev/simple_sqlite.py

@@ -2,7 +2,7 @@ import sqlite3 , os  ,time
 from .debugger import DEBUGGER
 from .utils import getRandomKey
 from .custom_env import custom_env , setupEnvironment 
-from .utils import fixTupleForSql
+from .utils import fixTupleForSql, start_thread
 
 env = custom_env()
 
@@ -25,6 +25,7 @@ class initDB :
         self.lastCur = None
         self.lastCon=None
         self.id = id
+        self.optimized = False
         self.WAL_JOURNAL = WAL_JOURNAL
         self.applyDatabaseParams=True
         if not loggerName :
@@ -49,14 +50,25 @@ class initDB :
             results = tuple(list)
         return results
 
-    def db_connect(self,  WAL=False , timeout: int=30):
+    def optimize_database_for_multi_threading(self) :
+        cur , con = self.db_connect(db_optimize=False)
+        cur.execute('PRAGMA journal_mode = WAL;')
+        cur.execute('PRAGMA busy_timeout = 10000;')
+        cur.execute('PRAGMA wal_autocheckpoint = 10000;')
+        cur.execute('PRAGMA temp_store = MEMORY;')
+        cur.execute('PRAGMA fullfsync = OFF;')
+        cur.execute('PRAGMA wal_checkpoint_fullfsync = OFF;')
+        con.commit()
+        con.close()
+
+    def db_connect(self,  WAL=False , db_optimize = True , timeout: int=30):
         self.logger.debug(f'connecting to {self.db_file}')
-        self.con = sqlite3.connect(self.db_file , check_same_thread=False,timeout= timeout)
-        self.cur = self.con.cursor()
-        if WAL or self.WAL_JOURNAL :
-            self.con.execute("PRAGMA journal_mode=WAL;")
-            self.con.commit()
-        return  self.cur , self.con 
+        con= sqlite3.connect(self.db_file , check_same_thread=False,timeout= timeout)
+        cur = con.cursor()
+        if not self.optimized  and db_optimize :
+            self.optimize_database_for_multi_threading()
+            self.optimized = True
+        return  cur , con
 
     def execute_dict(self,cli:str) :
         self.logger.debug(f"execute_dict: {cli}")
@@ -69,10 +81,15 @@ class initDB :
         conn.close()
         return h
     
-    def vacuum(self) :
+    def vacuum(self , table=None) :
         try :
             cur , conn = self.db_connect()
             cur.execute('VACUUM')
+            cur.execute("PRAGMA optimize")
+            if table : 
+                cur.execute(f"update sqlite_sequence set seq=0 where name='{table}'")
+            else :
+                cur.execute(f"update sqlite_sequence set seq=0")
             conn.commit()
             conn.close()
         except :

{easy_utils_dev-2.172 → easy_utils_dev-2.174}/easy_utils_dev/uiserver.py

@@ -1,35 +1,34 @@
 import gc
 import json
 import time
-from flask.ctx import F
+import logging
+import os
+import traceback
+import threading
+import signal
+import sys
 from werkzeug.serving import ThreadedWSGIServer
 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
+from flask import request , current_app , copy_current_request_context
 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
-import traceback
 from werkzeug.serving import make_ssl_devcert
 from time import sleep
-from easy_utils_dev.utils import start_thread , getRandomKeysAndStr , mkdirs , lget
+from easy_utils_dev.utils import start_thread , getRandomKeysAndStr
 from easy_utils_dev.temp_memory import TemporaryMemory
 from easy_utils_dev.debugger import DEBUGGER
-import signal
-import sys 
 from tempfile import gettempdir
 from urllib.parse import urlparse, parse_qs
+from easy_utils_dev.KeycloakAuthExtension import Permissions
 
 TMP_PATH = gettempdir()
 
-
 def extract_buid(url: str , key ) -> str | None:
     """
     Extracts the 'buid' query parameter from a URL.
@@ -224,6 +223,7 @@ class SocketClientObject :
         self.browserid = None
 
 class UISERVER :
+
     def __init__(self ,
             logger : DEBUGGER = None,
             id=getRandomKey(n=15),
@@ -236,9 +236,73 @@ class UISERVER :
             ssl_key=None,
             template_folder='templates/' ,
             static_folder = 'templates/assets',
-            socketio_async_mode = "threading"
-            ,**kwargs
+            socketio_async_mode = "threading",
+            keycloak_integration=False,
+            **kwargs
         ) -> None:
+        """
+        Initialize the application server configuration.
+
+        Parameters
+        ----------
+        logger : DEBUGGER, optional
+                    Custom logger instance used for application logging.
+                    If None, default logger behavior is used.
+
+                id : str, optional
+                    Unique identifier for the application instance.
+                    Generated automatically if not provided.
+
+                secretkey : str, optional
+                    Secret key used for internal authentication, sessions,
+                    or secure operations. Auto-generated by default.
+
+                serve_with_secret_key : bool, optional
+                    If True, the server will require the secret key
+                    for certain protected operations or endpoints.
+
+                address : str, optional
+                    Host address to bind the server to.
+                    Default is 'localhost'.
+
+                port : int, optional
+                    Port number the server will listen on.
+                    Default is 5312.
+
+                https : bool, optional
+                    Enable HTTPS support.
+                    If True, ssl_crt and ssl_key must be provided.
+
+                ssl_crt : str or None, optional
+                    Path to the SSL certificate file (PEM/CRT).
+                    Required if https=True.
+
+                ssl_key : str or None, optional
+                    Path to the SSL private key file.
+                    Required if https=True.
+
+                template_folder : str, optional
+                    Path to the templates directory used by the web framework.
+
+                static_folder : str, optional
+                    Path to the static assets directory (CSS, JS, images).
+
+                socketio_async_mode : str, optional
+                    Async mode used by Socket.IO.
+                    Common values: 'threading', 'eventlet', 'gevent'.
+
+                keycloak_integration : bool, optional
+                    Enable Keycloak authentication integration if True.
+
+                **kwargs : dict
+                    Additional keyword arguments passed to the underlying
+                    framework or server configuration.
+
+                Notes
+                -----
+                - HTTPS requires valid SSL certificate and key.
+                - Secret keys should be kept secure in production environments.
+            """
         self.id = id
         self.static_folder = static_folder
         self.app = app = Flask(self.id , template_folder=template_folder  ,  static_folder=self.static_folder )
@@ -289,8 +353,19 @@ class UISERVER :
                 name='webserver',
                 homePath=TMP_PATH
             )
+        if keycloak_integration :
+            self.auth = Permissions(
+                home=self.logger._home ,
+                redirect_url=kwargs.get('keycloak_redirect_url') ,
+                keycloak_url=kwargs.get('keycloak_home_url') ,
+                callback_url=kwargs.get('keycloak_callback_url'),
+                webserver=self
+            )
+        else :
+            self.auth = None
         self.start_before_request()
 
+
     def update_cert(self , crt, ssl ) :
         self.ssl_crt=crt
         self.ssl_key=ssl
@@ -624,4 +699,70 @@ class UISERVER :
             except:
                 pass
         kill_thread(self.thread)
-        return True
+        return True
+class WebServer(UISERVER):
+    def __init__(self , *args , **kwargs) :
+        """
+        Initialize the application server configuration.
+
+            Parameters
+            ----------
+            logger : DEBUGGER, optional
+                Custom logger instance used for application logging.
+                If None, default logger behavior is used.
+
+            id : str, optional
+                Unique identifier for the application instance.
+                Generated automatically if not provided.
+
+            secretkey : str, optional
+                Secret key used for internal authentication, sessions,
+                or secure operations. Auto-generated by default.
+
+            serve_with_secret_key : bool, optional
+                If True, the server will require the secret key
+                for certain protected operations or endpoints.
+
+            address : str, optional
+                Host address to bind the server to.
+                Default is 'localhost'.
+
+            port : int, optional
+                Port number the server will listen on.
+                Default is 5312.
+
+            https : bool, optional
+                Enable HTTPS support.
+                If True, ssl_crt and ssl_key must be provided.
+
+            ssl_crt : str or None, optional
+                Path to the SSL certificate file (PEM/CRT).
+                Required if https=True.
+
+            ssl_key : str or None, optional
+                Path to the SSL private key file.
+                Required if https=True.
+
+            template_folder : str, optional
+                Path to the templates directory used by the web framework.
+
+            static_folder : str, optional
+                Path to the static assets directory (CSS, JS, images).
+
+            socketio_async_mode : str, optional
+                Async mode used by Socket.IO.
+                Common values: 'threading', 'eventlet', 'gevent'.
+
+            keycloak_integration : bool, optional
+                Enable Keycloak authentication integration if True.
+
+            **kwargs : dict
+                Additional keyword arguments passed to the underlying
+                framework or server configuration.
+
+            Notes
+            -----
+            - HTTPS requires valid SSL certificate and key.
+            - Secret keys should be kept secure in production environments.
+        """
+        super().__init__(*args , **kwargs)

{easy_utils_dev-2.172 → easy_utils_dev-2.174}/easy_utils_dev/wsnoclib.py

@@ -133,6 +133,32 @@ class WSNOCLIB :
     def getSession(self) :
         return self.session
 
+    def getZicCardView(self,neName , return_dict=True , return_json=False ) : 
+        import js2py
+        cookies = {
+            "ycsm": f"token%3DWebSessionId%3D{self.access_token}",
+            "EQMWebUITimeoutCookie": "15",
+        }
+        response = self.session.get(f"https://{self.address}:9213/{neName}/scripts/cardview.js", cookies=cookies)
+        js = originalJs = response.text
+        if len(js) < 1000 :
+            self.logger.error(f'Failed to get cardview.js. Response: {response.text}')
+            return None
+        if return_dict or return_json :
+            js = "var isOMSUser = true;" + js
+            js = js + """
+            function getData(){
+                return JSON.stringify(CARDOBJECT)
+            }"""
+            js =js.replace('new Array();', 'Object.create(null);')
+            ctx = js2py.EvalJs()
+            ctx.execute(js)
+            cards = ctx.getData()
+            if return_json :
+                return cards
+            return json.loads(cards)
+        return originalJs
+
     def connect(self,auto_refresh_token=True) -> dict :
         self.auto_refresh_token = auto_refresh_token 
         #refresh the session

{easy_utils_dev-2.172 → easy_utils_dev-2.174}/easy_utils_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easy_utils_dev
-Version: 2.172
+Version: 2.174
 Keywords: python3
 Classifier: Programming Language :: Python :: 3
 Requires-Dist: psutil
@@ -19,6 +19,8 @@ Requires-Dist: pyzipper
 Requires-Dist: pyjwt
 Requires-Dist: authlib
 Requires-Dist: kafka-python
+Requires-Dist: cachetools
+Requires-Dist: js2py
 Dynamic: classifier
 Dynamic: keywords
 Dynamic: requires-dist

{easy_utils_dev-2.172 → easy_utils_dev-2.174}/easy_utils_dev.egg-info/SOURCES.txt

@@ -1,8 +1,8 @@
-MANIFEST.in
 setup.py
 easy_utils_dev/EasySsh.py
 easy_utils_dev/Events.py
 easy_utils_dev/FastQueue.py
+easy_utils_dev/KeycloakAuthExtension.py
 easy_utils_dev/NameObject.py
 easy_utils_dev/__init__.py
 easy_utils_dev/abortable.py
@@ -37,4 +37,6 @@ easy_utils_dev.egg-info/dependency_links.txt
 easy_utils_dev.egg-info/requires.txt
 easy_utils_dev.egg-info/top_level.txt
 easy_utils_dev/ept_sql/create_dirs.sql
-easy_utils_dev/ept_sql/create_ept_tables.sql
+easy_utils_dev/ept_sql/create_ept_tables.sql
+playground/__init__.py
+playground/useapi.py

{easy_utils_dev-2.172 → easy_utils_dev-2.174}/easy_utils_dev.egg-info/requires.txt

@@ -14,3 +14,5 @@ pyzipper
 pyjwt
 authlib
 kafka-python
+cachetools
+js2py

{easy_utils_dev-2.172 → easy_utils_dev-2.174}/easy_utils_dev.egg-info/top_level.txt

@@ -1 +1,2 @@
 easy_utils_dev
+playground

easy_utils_dev-2.174/playground/useapi.py

@@ -0,0 +1,30 @@
+# Add the parent directory to sys.path to allow importing easy_utils_dev
+import sys , os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from flask import request
+from easy_utils_dev import utils
+from easy_utils_dev.uiserver import WebServer
+
+server = WebServer(
+    address='127.0.0.1',
+    port=3001,
+)
+
+app = server.app
+
+@app.route('/api/users' , methods=['GET'])
+def _api_get_users():
+    return server.Response.ok(users=[{'name': 'John Doe', 'age': 30}, {'name': 'Jane Doe', 'age': 25}])
+
+@app.route('/api/checktoken' , methods=['GET'])
+def api_checktoken():
+    print(request.headers.get('Authorization'))
+    return server.Response.ok()
+
+@app.route('/api/notify' , methods=['GET'])
+def api_notify_test():
+    return server.Response.ok(toast=True , message=utils.getTimestamp())
+
+
+if __name__ == "__main__":
+    server.startUi(block=True)

{easy_utils_dev-2.172 → easy_utils_dev-2.174}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-VERSION = '2.172'
+VERSION = '2.174'
 
 # Setting up
 setup(
@@ -24,7 +24,9 @@ setup(
         'pyzipper',
         'pyjwt',
         'authlib',
-        'kafka-python'
+        'kafka-python',
+        'cachetools',
+        'js2py'
     ],
     keywords=['python3'],
     classifiers=[

easy_utils_dev-2.172/MANIFEST.in

@@ -1 +0,0 @@
-recursive-include easy_utils_dev/ept_sql *.sql