files

src/.env

@@ -0,0 +1,10 @@
+workers=1
+
+WORKERS="${workers}"
+# DB_NAME="${dbname}"
+# DB_USERNAME="${username}"
+# DB_PWD="${password}"
+# DB_IP="${ipaddress}"
+# DB_PORT="${port}"
+# MONGO_PATH="mongodb://${DB_USERNAME}:${DB_PWD}@${DB_IP}:${DB_PORT}/"
+# MONGO_PATH= "mongodb://localhost:27017/"

src/config/config.py

@@ -0,0 +1,36 @@
+'''
+Copyright 2024-2025 Infosys Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+from configparser import ConfigParser
+import yaml
+
+
+def readConfig(section,filename):
+    # create a parser
+    parser = ConfigParser()
+    # read config file
+    parser.read(filename)
+
+    # get section, default to postgresql
+    db = {}
+    if parser.has_section(section):
+        params = parser.items(section)
+        for param in params:
+            db[param[0]] = param[1]
+    else:
+        raise Exception('Section {0} not found in the {1} file'.format(section, filename))
+
+    return db
+
+
+def read_config_yaml(filename):
+    with open(filename) as config_file:
+        config_details = yaml.safe_load(config_file)
+    return config_details

src/config/logger.py

@@ -0,0 +1,166 @@
+'''
+Copyright 2024-2025 Infosys Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+import datetime
+import logging
+import os
+import sys
+from .config import readConfig
+import contextvars
+
+request_id_var = contextvars.ContextVar("request_id_var")
+
+class CustomLogger(logging.getLoggerClass()):
+    def __init__(self):
+        """Create a custom logger with the specified `name`. When `log_dir` is None, a simple
+        console logger is created. Otherwise, a file logger is created in addition to the console
+        logger.
+
+        By default, the five standard logging levels (DEBUG through CRITICAL) only display
+        information in the log file if a file handler is added to the logger, but **not** to the
+        console.
+        :param name: name for the logger
+        :param verbose: bool: whether the logging should be verbose; if True, then all messages get
+            logged both to stdout and to the log file (if `log_dir` is specified); if False, then
+            messages only get logged to the log file (if `log_dir` is specified)
+        :param log_dir: str: (optional) the directory for the log file; if not present, no log file
+            is created
+        """
+        # Create custom logger logging all five levels
+        BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        log_cfg_path = os.path.join(BASE_DIR, 'logger.ini')
+        log_params = readConfig('logDetails', log_cfg_path)
+        name = log_params['file_name']
+        try:
+            verbose = bool(log_params['verbose'])
+        except:
+            verbose = False
+
+        log_dir = str(log_params['log_dir'])
+
+        super().__init__(name)
+        self.setLevel(logging.DEBUG)
+
+        # Add new logging level
+        logging.addLevelName(logging.INFO, 'INFO')
+
+        # Determine verbosity settings
+        self.verbose = verbose
+
+        # Create stream handler for logging to stdout (log all five levels)
+        self.stdout_handler = logging.StreamHandler(sys.stdout)
+        self.stdout_handler.setLevel(logging.DEBUG)
+        self.stdout_handler.setFormatter(logging.Formatter('%(message)s'))
+        self.enable_console_output()
+
+        self.file_handler = None
+        if log_dir:
+            self.add_file_handler(name, log_dir)
+
+    def add_file_handler(self, name, log_dir):
+        """Add a file handler for this logger with the specified `name` (and store the log file
+        under `log_dir`)."""
+        # Format for file log
+        fmt = '%(asctime)s | %(levelname)9s | %(filename)s:%(lineno)d | %(user_id)s | %(message)s '
+        formatter = logging.Formatter(fmt)
+
+        # Determine log path and file name; create log path if it does not exist
+        now = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+        log_name = f'{str(name).replace(" ", "_")}_{now}'
+        if not os.path.exists(log_dir):
+            try:
+                os.makedirs(log_dir)
+            except:
+                print(f'{self.__class__.__name__}: Cannot create directory {log_dir}. ',
+                      end='', file=sys.stderr)
+                log_dir = '/tmp' if sys.platform.startswith('linux') else '.'
+                print(f'Defaulting to {log_dir}.', file=sys.stderr)
+
+        log_file = os.path.join(log_dir, log_name) + '.log'
+
+        # Create file handler for logging to a file (log all five levels)
+        self.file_handler = logging.FileHandler(log_file)
+        self.file_handler.setLevel(logging.DEBUG)
+        self.file_handler.setFormatter(formatter)
+        self.addHandler(self.file_handler)
+
+    def has_console_handler(self):
+        return len([h for h in self.handlers if type(h) == logging.StreamHandler]) > 0
+
+    def has_file_handler(self):
+        return len([h for h in self.handlers if isinstance(h, logging.FileHandler)]) > 0
+
+    def disable_console_output(self):
+        if not self.has_console_handler():
+            return
+        self.removeHandler(self.stdout_handler)
+
+    def enable_console_output(self):
+        if self.has_console_handler():
+            return
+        self.addHandler(self.stdout_handler)
+
+    def disable_file_output(self):
+        if not self.has_file_handler():
+            return
+        self.removeHandler(self.file_handler)
+
+    def enable_file_output(self):
+        if self.has_file_handler():
+            return
+        self.addHandler(self.file_handler)
+
+    def framework(self, msg, *args, **kwargs):
+        """Logging method for the FRAMEWORK level. The `msg` gets logged both to stdout and to file
+        (if a file handler is present), irrespective of verbosity settings."""
+        return super().info(msg, *args, **kwargs)
+
+    def _custom_log(self, func, msg, *args, **kwargs):
+        """Helper method for logging DEBUG through CRITICAL messages by calling the appropriate
+        `func()` from the base class."""
+        # Log normally if verbosity is on
+        if self.verbose:
+            return func(msg, *args, **kwargs)
+
+        # If verbosity is off and there is no file handler, there is nothing left to do
+        if not self.has_file_handler():
+            return
+
+        # If verbosity is off and a file handler is present, then disable stdout logging, log, and
+        # finally reenable stdout logging
+        self.disable_console_output()
+        func(msg, *args, **kwargs)
+        self.enable_console_output()
+
+    def getSeesionId():
+        try:
+            request_id = request_id_var.get()
+        except Exception as e:
+            request_id = "StartUp"
+        return request_id
+    
+    def debug(self, msg, *args, **kwargs ):
+        self._custom_log(super().debug, str(datetime.datetime.now())+"  :  "+msg,extra = {'user_id':CustomLogger.getSeesionId()}, *args, **kwargs)
+
+    def info(self, msg, *args, **kwargs):
+        self._custom_log(super().info, str(datetime.datetime.now())+"  :  "+msg,extra = {'user_id':CustomLogger.getSeesionId()}, *args, **kwargs)
+
+    def warning(self, msg,user_id=None, *args, **kwargs):
+        self._custom_log(super().warning,str(datetime.datetime.now())+"  :  "+msg,extra = {'user_id':CustomLogger.getSeesionId()}, *args, **kwargs)
+
+    def error(self, msg,user_id=None, *args, **kwargs):
+        self._custom_log(super().error,str(datetime.datetime.now())+"  :  "+msg,extra = {'user_id':CustomLogger.getSeesionId()}, *args, **kwargs)
+
+    def critical(self, msg,user_id=None, *args, **kwargs):
+        self._custom_log(super().critical,str(datetime.datetime.now())+"  :  "+msg,extra = {'user_id':CustomLogger.getSeesionId()}, *args, **kwargs)
+
+
+if __name__ == "__main__":
+    CustomLogger()

src/constants/local_constants.py

@@ -0,0 +1,27 @@
+'''
+Copyright 2024-2025 Infosys Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+"""
+fileName: local_constants.py
+description: Local constants for usecase  module
+"""
+
+DELTED_SUCCESS_MESSAGE="Successfully deleted the usecase :"
+USECASE_ALREADY_EXISTS= "Usecase with name PLACEHOLDER_TEXT already exists"
+USECASE_NOT_FOUND_ERROR="Usecase id PLACEHOLDER_TEXT Not Found"
+USECASE_NAME_VALIDATION_ERROR="Usecase name should not be empty"
+SPACE_DELIMITER=" "
+PLACEHOLDER_TEXT="PLACEHOLDER_TEXT"
+HTTP_STATUS_BAD_REQUEST=500
+HTTP_STATUS_NOT_FOUND=404
+HTTP_STATUS_409_CODE=409
+HTTP_422_UNPROCESSABLE_ENTITY="422"
+HTTP_415_UNSUPPORTED_MEDIA_TYPE=415
+UNSUPPPORTED_MEDIA_TYPE_ERROR="Unsupported media type: "

src/dao/AdminDb.py

@@ -0,0 +1,76 @@
+'''
+Copyright 2024-2025 Infosys Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+import os
+import pymongo
+
+from dotenv import load_dotenv
+import sys
+load_dotenv()
+import json
+import requests
+import urllib.parse
+
+import requests
+import json
+import traceback
+import os
+
+import logging
+
+class AttributeDict(dict):
+    __getattr__ = dict.__getitem__
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+myclient = pymongo.MongoClient(os.getenv("MONGO_PATH"))
+print(myclient)
+# dbname = os.getenv("APP_MONGO_DBNAME")
+dbname = os.getenv("DB_NAME")
+
+class DB:
+    def connect():
+        try:
+            # myclient = pymongo.MongoClient(os.getenv("MONGO_PATH")) 
+            # mydb = myclient[os.getenv("DB_NAME")]
+            mydb = myclient[dbname]
+            
+            return mydb
+        except Exception as e:
+            logging.error("error in DB connection")
+            logging.error(str(e))
+            sys.exit()
+
+mydb=DB.connect()
+
+
+class Results:
+    mycol = mydb["moderationtelemetrydata"]
+    logdb=mydb["Logdb"]
+    # mycol = mydb["Results"]
+    mycol2 = mydb["Results"]
+    # mycol2 = mydb["Resultswithfeedback"]
+
+
+    def createlog(value):
+        
+        try:
+            print(value)
+            PtrnRecogCreatedData = Results.logdb.insert_one(value)
+            print("PtrnRecogCreatedData.acknowledged",PtrnRecogCreatedData.acknowledged)
+            return PtrnRecogCreatedData.acknowledged
+        except Exception as e:
+            logging.error("Error occured in Results create")
+            logging.error(f"Exception: {e}")
+    
+    
+    
+            

src/dao/temp.txt

@@ -0,0 +1,24 @@
+fastapi
+pydantic
+uvicorn
+certifi
+FastAPI-SQLAlchemy
+pip
+PyYAML
+pandas
+python-multipart
+pymongo
+python-dotenv
+requests
+requests-file
+setuptools
+SQLAlchemy
+starlette
+typer
+typing_extensions
+urllib3
+wasabi
+#https://huggingface.co/spacy/en_core_web_lg/resolve/main/en_core_web_lg-any-py3-none-any.whl
+#../lib/presidio_analyzer-4.0.6-py3-none-any.whl
+../lib/aicloudlibs-0.1.0-py3-none-any.whl
+#../lib/en_core_web_lg-any-py3-none-any.whl

src/exception/exception.py

@@ -0,0 +1,48 @@
+'''
+Copyright 2024-2025 Infosys Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+"""
+fileName: exception.py
+description: handles usecase module specific exception
+"""
+import sys, traceback
+from constants.local_constants  import SPACE_DELIMITER,PLACEHOLDER_TEXT,USECASE_ALREADY_EXISTS,USECASE_NOT_FOUND_ERROR,USECASE_NAME_VALIDATION_ERROR
+from constants import local_constants as global_constants
+
+from abc import ABC
+
+
+class modeldeploymentException(Exception, ABC):
+    """
+    description: Abstract base class of UsecaseException.
+    """
+
+    def __init__(self, detail: str) -> None:
+        self.status_code = global_constants.HTTP_STATUS_BAD_REQUEST
+        super().__init__(detail)
+
+
+class modeldeploymentNotFoundError(modeldeploymentException):
+    """
+    description: UsecaseNotFoundError thrown by usecase service
+                 when the requested usecase details not found for a specific user.
+    """
+    def __init__(self,name):
+        self.status_code = global_constants.HTTP_STATUS_NOT_FOUND
+        self.detail =  USECASE_NOT_FOUND_ERROR.replace(PLACEHOLDER_TEXT,name)
+
+class modeldeploymentNameNotEmptyError(modeldeploymentException):
+    """
+    description: UsecaseNameNotEmptyError thrown by create usecase service
+                 when the requested usecase details not having usecase name.
+    """
+    def __init__(self,name):
+        self.status_code = global_constants.HTTP_STATUS_409_CODE
+        self.detail =  USECASE_NAME_VALIDATION_ERROR

src/exestep.txt

@@ -0,0 +1,10 @@
+// MIT license https://opensource.org/licenses/MIT
+// Copyright 2024 Infosys Ltd
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+pyinstaller --onedir --add-data "C:\WORK\GIT\responsible-ai-mm-flask\myenv\Lib\site-packages;." --add-data "C:\WORK\GIT\responsible-ai-mm-flask\models;models" main.py                                                                                                                       

src/logger.ini

@@ -0,0 +1,5 @@
+[logDetails]
+LOG_LEVEL=ERROR
+FILE_NAME=responsible-ai-servicelogs
+VERBOSE=False
+LOG_DIR=/responsible-ai/logs

src/main.py

@@ -0,0 +1,58 @@
+'''
+Copyright 2024-2025 Infosys Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+import os
+from flask import Flask,request,jsonify
+from flask_swagger_ui import get_swaggerui_blueprint
+from routing.router import router
+from config.logger import CustomLogger,request_id_var
+from waitress import serve
+from werkzeug.exceptions import HTTPException,UnsupportedMediaType,BadRequest
+# from mapper.mapper import *
+
+SWAGGER_URL = '/rai/v1/raimoderationmodels/docs'  
+API_URL = '/static/swagger.json'
+
+swaggerui_blueprint = get_swaggerui_blueprint(
+    SWAGGER_URL, 
+    API_URL
+)
+
+log=CustomLogger()
+app = Flask(__name__)
+app.register_blueprint(swaggerui_blueprint)
+app.register_blueprint(router,url_prefix='/rai/v1/raimoderationmodels')
+
+
+def handle_http_exception(exc):
+    """Handles HTTP exceptions, returning a JSON response."""
+    response = jsonify({"error": exc.description})
+    response.status_code = exc.code
+    return response
+
+@app.errorhandler(HTTPException)
+def handle_all_http_exceptions(exc):
+    """Global exception handler for HTTP errors."""
+    return handle_http_exception(exc)
+
+def handle_unsupported_mediatype(exc):
+    """Handles unsupported media type exceptions."""
+    return jsonify({"error": "Unsupported media type"}), 415  # 415 Unsupported Media Type
+
+@app.errorhandler(UnsupportedMediaType)
+def handle_all_unsupported_mediatype_exceptions(exc):
+    """Global exception handler for unsupported media types."""
+    return handle_unsupported_mediatype(exc)
+
+
+if __name__ == "__main__":
+   serve(app, host='0.0.0.0', port=7860, threads=int(os.getenv('THREADS',1)),connection_limit=int(os.getenv('CONNECTION_LIMIT',500)), channel_timeout=int(os.getenv('CHANNEL_TIMEOUT',120)))
+   #app.run()
+

src/main_test.py

@@ -0,0 +1,494 @@
+'''
+Copyright 2024-2025 Infosys Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+import pickle
+import torch
+import os
+import time
+import logging
+from flask import Flask, render_template, request, jsonify
+from flask import g
+from datetime import datetime
+import json
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+from sentence_transformers import SentenceTransformer,util
+from detoxify import Detoxify
+from presidio_analyzer import AnalyzerEngine, RecognizerRegistry
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, pipeline
+from dao.AdminDb import Results
+from werkzeug.exceptions import HTTPException,BadRequest,UnprocessableEntity,InternalServerError
+from tqdm.auto import tqdm
+from fastapi.encoders import jsonable_encoder
+
+
+import numpy as np
+
+import traceback
+import uuid
+from waitress import serve
+from mapper.mapper import *
+import contextvars
+
+app = Flask(__name__)
+print("before loading model")
+request_id_var = contextvars.ContextVar("request_id_var")
+#pipe = StableDiffusionPipeline.from_pretrained('/model/stablediffusion/fp32/model')
+device = "cuda"
+registry = RecognizerRegistry()
+registry.load_predefined_recognizers()
+analyzer_engine = AnalyzerEngine(registry=registry)
+
+device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+gpu=0 if torch.cuda.is_available() else -1
+check_point = 'toxic_debiased-c7548aa0.ckpt'
+toxicityModel = Detoxify(checkpoint='../models/detoxify/'+ check_point,
+                        device=device,
+                        huggingface_config_path='../models/detoxify')
+
+PromptModel_dberta = AutoModelForSequenceClassification.from_pretrained("../models/dbertaInjection").to(device)
+Prompttokens_dberta = AutoTokenizer.from_pretrained("../models/dbertaInjection")
+
+topictokenizer_Facebook = AutoTokenizer.from_pretrained("../models/facebook")
+topicmodel_Facebook = AutoModelForSequenceClassification.from_pretrained("../models/facebook").to(device)
+
+topictokenizer_dberta = AutoTokenizer.from_pretrained("../models/restricted-dberta-large-zeroshot")
+topicmodel_dberta = AutoModelForSequenceClassification.from_pretrained("../models/restricted-dberta-large-zeroshot").to(device)
+
+# classifier = pipeline("zero-shot-classification",model="../models/facebook",device=device)
+# classifier2 = pipeline("zero-shot-classification",model="../models/restricted-dberta-large-zeroshot",device=device)
+encoder = SentenceTransformer("../models/multi-qa-mpnet-base-dot-v1").to(device)
+jailbreakModel = encoder
+similarity_model =encoder
+request_id_var.set("Startup")
+log_dict={}
+print("model loaded")
+
+@app.errorhandler(HTTPException)
+def handle_exception(e):
+    """Return JSON instead of HTML for HTTP errors."""
+    # start with the correct headers and status code from the error
+    response = e.get_response()
+    # replace the body with JSON
+    response.data = json.dumps({
+        "code": e.code,
+        "details": e.description,
+    })
+    response.content_type = "application/json"
+    return response
+
+@app.errorhandler(UnprocessableEntity)
+def validation_error_handler(exc):
+        """Return JSON instead of HTML for HTTP errors."""
+        # start with the correct headers and status code from the error
+        response = exc.get_response()
+        print(response)
+        # replace the body with JSON
+        exc_code_desc=exc.description.split("-")
+        exc_code=int(exc_code_desc[0])
+        exc_desc=exc_code_desc[1]
+        response.data = json.dumps({
+            "code": exc_code,
+            "details":  exc_desc,
+        })
+        response.content_type = "application/json"
+        return response
+
+@app.errorhandler(InternalServerError)
+def validation_error_handler(exc):
+        """Return JSON instead of HTML for HTTP errors."""
+        # start with the correct headers and status code from the error
+        response = exc.get_response()
+        print(response)
+        # replace the body with JSON
+        response.data = json.dumps({
+            "code": 500,
+            "details": "Some Error Occurred ,Please try Later",
+        })
+        response.content_type = "application/json"
+        return response
+
+@app.route("/rai/v2test/raimoderationmodels/detoxifymodel",methods=[ 'POST'])
+def toxic_model():
+    st=time.time()
+    
+    try:
+        
+        id=uuid.uuid4().hex
+        payload=request.get_json()
+        request_id_var.set(id)
+        logging.info("before invoking toxic_model service ")
+        log_dict[request_id_var.get()]=[]
+        if payload['text'] is None or (payload['text'] is not None and len(payload['text'])==0):
+            raise UnprocessableEntity("1021-Input Text should not be empty ")
+        response = toxicity_check(payload,id)
+ 
+        logging.info("after invoking toxic_model service ")
+        
+        er=log_dict[request_id_var.get()]
+        logobj = {"_id":id,"error":er}
+	
+
+        if len(er)!=0:
+            Results.createlog(logobj)
+        del log_dict[id]
+        logging.debug("response : " + str(response))
+        logging.info("exit toxic_model routing method")
+        logging.info(f"Time taken by toxicity {time.time()-st}")
+        return jsonable_encoder(response)
+    except UnprocessableEntity as cie:
+        logging.error(cie.__dict__)
+        logging.info("exit toxic_model routing method")
+        raise UnprocessableEntity(**cie.__dict__)
+    except Exception as cie:
+        logging.error(cie.__dict__)
+        logging.info("exit toxic_model routing method")
+        raise HTTPException()
+    
+@app.route("/rai/v2test/raimoderationmodels/privacy",methods=[ 'POST'])
+def pii_check():
+    st=time.time()
+    logging.info("Entered pii_check routing method")
+    try:
+        
+        id=uuid.uuid4().hex
+        payload=request.get_json()
+        request_id_var.set(id)
+        logging.info("before invoking create usecase service ")
+        log_dict[request_id_var.get()]=[]
+        if payload['text'] is None or (payload['text'] is not None and len(payload['text'])==0) or payload['entitiesselected'] is None or (payload['entitiesselected'] is not None and len(payload['entitiesselected'])==0):
+            raise UnprocessableEntity("1021-invalid input!")
+        response = privacy(id,payload['text'],payload['entitiesselected'])
+        logging.info("after invoking create usecase service ")
+        er=log_dict[request_id_var.get()]
+        logobj = {"_id":id,"error":er}
+        if len(er)!=0:
+            Results.createlog(logobj)
+        del log_dict[id]
+        logging.debug("response : " + str(response))
+        # logging.debug("response : " + str(response))
+        logging.info("exit pii_check routing method")
+        logging.info(f"Time taken by privacy {time.time()-st}")
+        return jsonable_encoder(response)
+    except Exception as cie:
+        logging.error(cie.__dict__)
+        logging.info("exit pii_check routing method")
+        raise HTTPException()
+    
+@app.route("/rai/v2test/raimoderationmodels/promptinjectionmodel",methods=[ 'POST'])
+def prompt_model():
+    st=time.time()
+    logging.info("Entered prompt_model routing method")
+    try:
+        
+        id=uuid.uuid4().hex
+        payload=request.get_json()
+        request_id_var.set(id)
+        logging.info("before invoking prompt_model service")
+        log_dict[request_id_var.get()]=[]
+        if payload['text'] is None or (payload['text'] is not None and len(payload['text'])==0):
+            raise UnprocessableEntity("1021-Input Text should not be empty ")
+        response = promptInjection_check(payload['text'],id)
+        logging.info("after invoking prompt_model service ")
+        er=log_dict[request_id_var.get()]
+        logobj = {"_id":id,"error":er}
+        if len(er)!=0:
+            Results.createlog(logobj)
+        del log_dict[id]
+        logging.debug("response : " + str(response))
+        # logging.debug("response : " + str(response))
+        logging.info("exit prompt_model routing method")
+        logging.info(f"Time taken by promptinjection {time.time()-st}")
+        return jsonable_encoder(response)
+    except Exception as cie:
+        logging.error(cie.__dict__)
+        logging.info("exit prompt_model routing method")
+        raise HTTPException()
+    
+@app.route("/rai/v2test/raimoderationmodels/restrictedtopicmodel",methods=[ 'POST'])
+def restrictedTopic_model():
+    st=time.time()
+    logging.info("Entered restrictedTopic_model routing method")
+    try:
+        id=uuid.uuid4().hex
+        payload=request.get_json()
+        request_id_var.set(id)
+        logging.info("before invoking restrictedTopic_model service ")
+        log_dict[request_id_var.get()]=[]
+
+        label_cond = payload['labels'] is None or (payload['labels'] is not None and len(payload['labels'])==0)
+        model_cond=False
+        # print("--")
+        if("model" in payload):
+            model_cond = payload['model'] is None or (payload['model'] is not None and len(payload['model'])==0)
+        # print("==")
+        if payload['text'] is None or (payload['text'] is not None and len(payload['text'])==0) or label_cond or model_cond:
+            raise UnprocessableEntity("1021-invalid input ")
+        response = restricttopic_check(payload,id)
+        logging.info("after invoking restrictedTopic_model service ")
+        er=log_dict[request_id_var.get()]
+        logobj = {"_id":id,"error":er}
+        if len(er)!=0:
+            Results.createlog(logobj)
+        del log_dict[id]
+        logging.debug("response : " + str(response))
+        # logging.debug("response : " + str(response))
+        logging.info("exit restrictedTopic_model routing method")
+        logging.info(f"Time taken by RestrictedTopic{time.time()-st}")
+        # print(type(response))
+        # print(type(jsonable_encoder(response)))
+        return jsonable_encoder(response)
+    except Exception as cie:
+        
+        logging.error(cie.__dict__)
+        logging.info("exit restrictedTopic_model routing method")
+        raise HTTPException()
+    
+@app.route("/rai/v2test/raimoderationmodels/multi_q_net_embedding",methods=[ 'POST'])
+def embedding_model():
+    st=time.time()
+    logging.info("Entered embedding_model routing method")
+    try:
+        
+        id=uuid.uuid4().hex
+        payload=request.get_json()
+        request_id_var.set(id)
+        logging.info("before invoking embedding_model service ")
+        log_dict[request_id_var.get()]=[]
+        if payload['text'] is None or (payload['text'] is not None and len(payload['text'])==0):
+            raise UnprocessableEntity("1021-Input Text should not be empty ")
+        response = multi_q_net_embedding(id,payload['text'])
+        logging.info("after invoking embedding_model service ")
+        er=log_dict[request_id_var.get()]
+        logobj = {"_id":id,"error":er}
+        if len(er)!=0:
+            Results.createlog(logobj)
+        del log_dict[id]
+        logging.debug("response : " + str(response))
+        # logging.debug("response : " + str(response))
+        logging.info("exit embedding_model routing method")
+        logging.info(f"Time taken by Jailbreak {time.time()-st}")
+        return jsonable_encoder(response)
+    except Exception as cie:
+        logging.error(cie.__dict__)
+        logging.info("exit embedding_model routing method")
+        raise HTTPException()
+
+@app.route("/rai/v2test/raimoderationmodels/multi-qa-mpnet-model_similarity",methods=[ 'POST'])
+def similarity_model():
+    st=time.time()
+    logging.info("Entered similarity_model routing method")
+    try:
+        
+        id=uuid.uuid4().hex
+        request_id_var.set(id)
+        logging.info("before invoking similarity_model service ")
+        payload=request.get_json()
+        log_dict[request_id_var.get()]=[]
+        text1_cond = payload['text1'] is None or (payload['text1'] is not None and len(payload['text1'])==0)
+        text2_cond = payload['text2'] is None or (payload['text2'] is not None and len(payload['text2'])==0)
+        emb1_cond = payload['emb1'] is None or (payload['emb1'] is not None and len(payload['emb1'])==0)
+        emb2_cond = payload['emb2'] is None or (payload['emb2'] is not None and len(payload['emb2'])==0)
+        if text1_cond or text2_cond or emb1_cond or emb2_cond:
+            raise UnprocessableEntity("1021-Input Text should not be empty ")
+        response = multi_q_net_similarity(id,payload['text1'],payload['text2'],payload['emb1'],payload['emb2'])
+        logging.info("after invoking similarity_model service ")
+        er=log_dict[request_id_var.get()]
+        logobj = {"_id":id,"error":er}
+        if len(er)!=0:
+            Results.createlog(logobj)
+        del log_dict[id]
+        logging.debug("response : " + str(response))
+        # logging.debug("response : " + str(response))
+        logging.info("exit similarity_model routing method")
+        logging.info(f"Time taken by similary{time.time()-st}")
+        return jsonable_encoder(response)
+    except Exception as cie:
+        logging.error(cie.__dict__)
+        logging.info("exit similarity_model routing method")
+        raise HTTPException()
+    
+
+def privacy(id,text,PIIenities_selected=None):  
+    try:
+        analyzer_results = analyzer_engine.analyze(text=text, language="en",entities=PIIenities_selected)
+        entityList= []
+        anyz_res = jsonable_encoder(analyzer_results)
+        for i in anyz_res:
+            entityList.append(i['entity_type'])
+        return anyz_res,jsonable_encoder(entityList)
+    except Exception as e:
+             
+            logging.error("Error occured in privacy")
+            logging.error(f"Exception: {e}")
+            log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+                                                   "Error Module":"Failed at privacy call"})
+            raise InternalServerError()
+            
+
+def multi_q_net_similarity(id,text1=None,text2=None,emb1=None,emb2=None):
+    try:
+        if text1:
+            with torch.no_grad():
+                emb1 = jailbreakModel.encode(text1, convert_to_tensor=True,device=device)
+        if text2:
+            with torch.no_grad():
+                emb2 = jailbreakModel.encode(text2, convert_to_tensor=True,device=device)
+        
+        emb = util.pytorch_cos_sim(emb1, emb2).to("cpu").numpy().tolist()
+        del emb1
+        del emb2
+        #torch.cuda.empty_cache()
+        return emb
+    except Exception as e:
+             
+            logging.error("Error occured in multi_q_net_similarity")
+            logging.error(f"Exception: {e}")
+            log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+                                                   "Error Module":"Failed at multi_q_net_similarity call"})
+            raise InternalServerError()
+            
+
+def multi_q_net_embedding(id,lst):
+    try:
+        res = []
+        for text in lst:
+            with torch.no_grad():
+                text_embedding = jailbreakModel.encode(text, convert_to_tensor=True,device=device)
+            res.append(text_embedding.to("cpu").numpy().tolist())
+
+        del text_embedding
+        #torch.cuda.empty_cache()
+        return res
+        # return text_embedding.numpy().tolist()
+    except Exception as e:
+             
+            logging.error("Error occured in multi_q_net text embedding")
+            logging.error(f"Exception: {e}")
+            log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+                                                   "Error Module":"Failed at multi_q_net text embedding call"})
+            raise InternalServerError()
+            
+
+def restricttopic_check(payload,id): 
+    try:
+        # topicmodel = topicmodel_Facebook
+        # topictokenizer = topictokenizer_Facebook
+
+        # nlp = pipeline('zero-shot-classification', model=classifier, tokenizer=topictokenizer)
+
+        text=payload['text']
+        labels=payload['labels']
+        
+        model =payload['model'] if hasattr(payload, 'model') else "facebook"
+        if model==None:
+            model="dberta"
+        
+        if model=="facebook":
+            # nlp = classifier
+            nlp = pipeline('zero-shot-classification', model=topicmodel_Facebook, tokenizer=topictokenizer_Facebook, device=gpu)
+        elif model=="dberta": 
+            # nlp = classifier2
+            nlp = pipeline('zero-shot-classification', model=topicmodel_dberta, tokenizer=topictokenizer_dberta,device=gpu)
+        with torch.no_grad():    
+            output=nlp(text, labels,multi_label=True)
+        for i in range(len(output["scores"])):
+            output["scores"][i] = round(output["scores"][i],4)
+
+        del nlp
+        #torch.cuda.empty_cache()
+        return output
+    
+    except Exception as e:
+             
+            logging.error("Error occured in restricttopic_check")
+            logging.error(f"Exception: {e}")
+            log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+                                                   "Error Module":"Failed at restricttopic_check call"})
+            raise InternalServerError()
+
+def toxicity_check(payload,id) :
+    try:
+        text = payload['text']
+        with torch.no_grad():
+            output = toxicityModel.predict(text)
+        List_profanity_score = []
+        obj_profanityScore_toxic = profanityScore(metricName='toxicity',
+                                        metricScore=output['toxicity'])
+        obj_profanityScore_severe_toxic = profanityScore(metricName='severe_toxicity',
+                                        metricScore=output['severe_toxicity'])
+        obj_profanityScore_obscene = profanityScore(metricName='obscene',
+                                        metricScore=output['obscene'])
+        obj_profanityScore_threat = profanityScore(metricName='threat',
+                                        metricScore=output['threat'])
+        obj_profanityScore_insult = profanityScore(metricName='insult',
+                                        metricScore=output['insult'])
+        obj_profanityScore_identity_attack = profanityScore(metricName='identity_attack',
+                                        metricScore=output['identity_attack'])
+        obj_profanityScore_sexual_explicit = profanityScore(metricName='sexual_explicit',
+                                        metricScore=output['sexual_explicit'])
+        
+        List_profanity_score.append(obj_profanityScore_toxic)
+        List_profanity_score.append(obj_profanityScore_severe_toxic)
+        List_profanity_score.append(obj_profanityScore_obscene)
+        List_profanity_score.append(obj_profanityScore_threat)
+        List_profanity_score.append(obj_profanityScore_insult)
+        List_profanity_score.append(obj_profanityScore_identity_attack)
+        List_profanity_score.append(obj_profanityScore_sexual_explicit)
+
+        objProfanityAnalyzeResponse = {}
+        objProfanityAnalyzeResponse['toxicScore'] = List_profanity_score
+
+        #torch.cuda.empty_cache()
+        return objProfanityAnalyzeResponse
+    
+    except Exception as e:
+             
+            logging.error("Error occured in toxicity_check")
+            logging.error(f"Exception: {e}")
+            log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+                                                   "Error Module":"Failed at toxicity_check call"})
+            raise InternalServerError()
+            
+    
+def promptInjection_check(text,id):
+    try:
+
+        Prompttokens = Prompttokens_dberta
+        PromptModel = PromptModel_dberta
+
+        tokens = Prompttokens.encode_plus(text, truncation=True, padding=True, return_tensors="pt").to(device)
+        
+        with torch.no_grad():
+            outputs = PromptModel(**tokens)
+
+        predicted_label = outputs.logits.argmax().item()
+        label_names = PromptModel.config.id2label
+        predicted_label_name = label_names[predicted_label]
+        predicted_probabilities = outputs.logits.softmax(dim=1)[0, predicted_label].item()
+
+        del tokens
+        #torch.cuda.empty_cache()
+        # #torch.cuda.empty_cache()
+        return predicted_label_name,predicted_probabilities
+    except Exception as e:
+            
+            logging.error("Error occured in promptInjection_check")
+            logging.error(f"Exception: {e}")
+            log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+                                                   "Error Module":"Failed at promptInjection_check call"})
+            raise InternalServerError()
+
+@app.route("/")
+def hello_world():
+    return "<h1>Hello, world!</h1>"            
+
+if __name__ == "__main__":
+   serve(app, host='0.0.0.0', port=8000, threads=int(os.getenv('THREADS',1)),connection_limit=int(os.getenv('CONNECTION_LIMIT',500)), channel_timeout=int(os.getenv('CHANNEL_TIMEOUT',120)))
+   #app.run()

src/mapper/__init__.py

@@ -0,0 +1 @@
+

src/mapper/mapper.py

@@ -0,0 +1,31 @@
+'''
+Copyright 2024-2025 Infosys Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+from pydantic import BaseModel, Field,Extra,ValidationError
+from typing import Optional, Union, List
+from enum import Enum
+
+
+class profanityScore(BaseModel):
+    metricName: str = Field(example="toxicity")
+    metricScore: float = Field(example=0.78326)
+
+    class Config:
+        orm_mode = True
+
+
+
+
+
+
+
+    
+
+

src/routing/router.py

@@ -0,0 +1,307 @@
+'''
+Copyright 2024-2025 Infosys Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+from flask import Blueprint
+import time
+# import logging
+from flask import request
+# from dao.AdminDb import Results
+from werkzeug.exceptions import HTTPException,UnprocessableEntity
+from tqdm.auto import tqdm
+# from fastapi.encoders import jsonable_encoder
+
+from service.service import *
+from config.logger import CustomLogger ,request_id_var
+
+import uuid
+from mapper.mapper import *
+import psutil
+
+request_id_var.set('Startup')
+router = Blueprint('router', __name__,)
+log=CustomLogger()
+
+@router.route("/detoxifymodel",methods=[ 'POST'])
+def toxic_model():
+    st=time.time()
+    stmem = psutil.Process().memory_info().rss
+    id=uuid.uuid4().hex
+    request_id_var.set(id)
+    try:
+        
+        # id=uuid.uuid4().hex
+        payload=request.get_json()
+        # request_id_var.set(id)
+        log.info("before invoking toxic_model service ")
+        log_dict[request_id_var.get()]=[]
+        if payload['text'] is None or (payload['text'] is not None and len(payload['text'])==0):
+            raise UnprocessableEntity("1021-Input Text should not be empty ")
+        response = toxicity_check(payload,id)
+ 
+        log.info("after invoking toxic_model service ")
+        
+        er=log_dict[request_id_var.get()]
+        logobj = {"_id":id,"error":er}
+	
+
+        if len(er)!=0:
+            log.debug(str(logobj))
+            # print("this is --> ",str(logobj) )
+        del log_dict[id]
+        log.debug("response : " + str(response))
+        log.info("exit toxic_model routing method")
+        log.info(f"Time taken by toxicity {time.time()-st}")
+        return jsonable_encoder(response)
+    except UnprocessableEntity as cie:
+        log.error(str(cie.__dict__))
+        log.info("exit toxic_model routing method")
+        raise UnprocessableEntity(**cie.__dict__)
+    except Exception as cie:
+        log.error(str(cie.__dict__))
+        log.info("exit toxic_model routing method")
+        raise HTTPException()
+    
+@router.route("/privacy",methods=[ 'POST'])
+def pii_check():
+    st=time.time()
+    id=uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered pii_check routing method")
+    try:
+        
+        # id=uuid.uuid4().hex
+        payload=request.get_json()
+        # request_id_var.set(id)
+        log.info("before invoking create usecase service ")
+        log_dict[request_id_var.get()]=[]
+        if payload['text'] is None or (payload['text'] is not None and len(payload['text'])==0):
+            raise UnprocessableEntity("1021-invalid input!")
+        response = privacy(id,payload['text'])
+        log.info("after invoking create usecase service ")
+        er=log_dict[request_id_var.get()]
+        logobj = {"_id":id,"error":er}
+        if len(er)!=0:
+            log.debug(str(logobj))
+        del log_dict[id]
+        log.debug("response : " + str(response))
+        # log.debug("response : " + str(response))
+        log.info("exit pii_check routing method")
+        log.info(f"Time taken by privacy {time.time()-st}")
+        return jsonable_encoder(response)
+    except UnprocessableEntity as cie:
+        log.error(str(cie.__dict__))
+        log.info("exit pii_check routing method")
+        raise UnprocessableEntity(**cie.__dict__)
+    except Exception as cie:
+        log.error(str(cie.__dict__))
+        log.info("exit pii_check routing method")
+        raise HTTPException()
+    
+@router.route("/promptinjectionmodel",methods=[ 'POST'])
+def prompt_model():
+    st=time.time()
+    id=uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered prompt_model routing method")
+    try:
+        
+        # id=uuid.uuid4().hex
+        payload=request.get_json()
+        # request_id_var.set(id)
+        log.info("before invoking prompt_model service")
+        log_dict[request_id_var.get()]=[]
+        if payload['text'] is None or (payload['text'] is not None and len(payload['text'])==0):
+            raise UnprocessableEntity("1021-Input Text should not be empty ")
+        response = promptInjection_check(payload['text'],id)
+        log.info("after invoking prompt_model service ")
+        er=log_dict[request_id_var.get()]
+        logobj = {"_id":id,"error":er}
+        if len(er)!=0:
+            log.debug(str(logobj))
+        del log_dict[id]
+        log.debug("response : " + str(response))
+        # log.debug("response : " + str(response))
+        log.info("exit prompt_model routing method")
+        log.info(f"Time taken by promptinjection {time.time()-st}")
+        return jsonable_encoder(response)
+    except UnprocessableEntity as cie:
+        log.error(str(cie.__dict__))
+        log.info("exit prompt_model routing method")
+        raise UnprocessableEntity(**cie.__dict__)
+    except Exception as cie:
+        log.error(str(cie.__dict__))
+        log.info("exit prompt_model routing method")
+        raise HTTPException()
+    
+@router.route("/restrictedtopicmodel",methods=[ 'POST'])
+def restrictedTopic_model():
+    st=time.time()
+    id=uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered restrictedTopic_model routing method")
+    try:
+        # id=uuid.uuid4().hex
+        payload=request.get_json()
+        # request_id_var.set(id)
+        log.info("before invoking restrictedTopic_model service ")
+        log_dict[request_id_var.get()]=[]
+
+        label_cond = payload['labels'] is None or (payload['labels'] is not None and len(payload['labels'])==0)
+        #model_cond=False
+        # print("--")
+        # if("model" in payload):
+        #     model_cond = payload['model'] is None or (payload['model'] is not None and len(payload['model'])==0)
+        # print("==")
+        if payload['text'] is None or (payload['text'] is not None and len(payload['text'])==0) or label_cond:
+            raise UnprocessableEntity("1021-invalid input ")
+        response = restricttopic_check(payload,id)
+        log.info("after invoking restrictedTopic_model service ")
+        er=log_dict[request_id_var.get()]
+        logobj = {"_id":id,"error":er}
+        if len(er)!=0:
+            log.debug(str(logobj))
+        del log_dict[id]
+        log.debug("response : " + str(response))
+        # log.debug("response : " + str(response))
+        log.info("exit restrictedTopic_model routing method")
+        log.info(f"Time taken by RestrictedTopic{time.time()-st}")
+        # print(type(response))
+        # print(type(jsonable_encoder(response)))
+        return jsonable_encoder(response)
+    except UnprocessableEntity as cie:
+        log.error(str(cie.__dict__))
+        log.info("exit restrictedTopic_model routing method")
+        raise UnprocessableEntity(**cie.__dict__)
+    except Exception as cie:
+        log.error(str(cie))       
+        log.error(str(cie.__dict__))
+        log.info("exit restrictedTopic_model routing method")
+        raise HTTPException()
+    
+@router.route("/multi_q_net_embedding",methods=[ 'POST'])
+def embedding_model():
+    st=time.time()
+    id=uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered embedding_model routing method")
+ 
+    try:
+        
+        # id=uuid.uuid4().hex
+        payload=request.get_json()
+        # request_id_var.set(id)
+
+        log.info("before invoking embedding_model service ")
+        log_dict[request_id_var.get()]=[]
+        if payload['text'] is None or (payload['text'] is not None and len(payload['text'])==0):
+            raise UnprocessableEntity("1021-Input Text should not be empty ")
+        response = multi_q_net_embedding(id,payload['text'])
+        log.info("after invoking embedding_model service ")
+        er=log_dict[request_id_var.get()]
+        logobj = {"_id":id,"error":er}
+        if len(er)!=0:
+            log.debug(str(logobj))
+        del log_dict[id]
+        # log.debug("response : " + str(response))
+        # log.debug("response : " + str(response))
+        log.info("exit embedding_model routing method")
+        log.info(f"Time taken by Jailbreak {time.time()-st}")
+        return jsonable_encoder(response)
+    except UnprocessableEntity as cie:
+        log.error(str(cie.__dict__))
+        log.info("exit embedding_model routing method")
+        raise UnprocessableEntity(**cie.__dict__)
+    except Exception as cie:
+        log.error(str(cie.__dict__))
+        log.info("exit embedding_model routing method")
+        raise HTTPException()
+
+@router.route("/multi-qa-mpnet-model_similarity",methods=[ 'POST'])
+def similarity_model():
+    st=time.time()
+    id=uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered similarity_model routing method")
+    try:
+        log.info("before invoking similarity_model service ")
+        payload=request.get_json()
+        log_dict[request_id_var.get()]=[]
+        emb1_cond=None
+        emb2_cond=None
+
+        text1_cond = payload['text1'] is None or (payload['text1'] is not None and len(payload['text1'])==0)
+        text2_cond = payload['text2'] is None or (payload['text2'] is not None and len(payload['text2'])==0)
+        if('emb1' in payload):
+                emb1_cond = payload['emb1'] is None or (payload['emb1'] is not None and len(payload['emb1'])==0)
+        else:
+            payload['emb1']=None
+        if('emb2' in payload):
+            emb2_cond = payload['emb2'] is None or (payload['emb2'] is not None and len(payload['emb2'])==0)
+        else:
+            payload['emb2']=None
+            
+        if text1_cond or text2_cond or emb1_cond or emb2_cond:
+            raise UnprocessableEntity("1021-Input Text should not be empty ")
+        response = multi_q_net_similarity(id,payload['text1'],payload['text2'],payload['emb1'],payload['emb2'])
+        log.info("after invoking similarity_model service ")
+        er=log_dict[request_id_var.get()]
+        logobj = {"_id":id,"error":er}
+        if len(er)!=0:
+            log.debug(str(logobj))
+        del log_dict[id]
+        log.debug("response : " + str(response))
+        # log.debug("response : " + str(response))
+        log.info("exit similarity_model routing method")
+        log.info(f"Time taken by similary{time.time()-st}")
+        return jsonable_encoder(response)
+    except UnprocessableEntity as cie:
+        log.error(str(cie.__dict__))
+        log.info("exit similarity_model routing method")
+        raise UnprocessableEntity(**cie.__dict__)
+    except Exception as cie:
+        log.error(str(cie.__dict__))
+        log.info("exit similarity_model routing method")
+        raise HTTPException()
+         
+# @router.route("/callmodel",methods=[ 'POST'])
+# def ml():
+#     st=time.time()
+#     id=uuid.uuid4().hex
+#     request_id_var.set(id)
+#     log.info("Entered embedding_model routing method")
+
+#     try:
+        
+#         # id=uuid.uuid4().hex
+#         payload=request.get_json()
+#         # request_id_var.set(id)
+
+#         log.info("before invoking embedding_model service ")
+#         log_dict[request_id_var.get()]=[]
+#         # if payload['text'] is None or (payload['text'] is not None and len(payload['text'])==0):
+#         #     raise UnprocessableEntity("1021-Input Text should not be empty ")
+#         response = checkall(id,payload)
+#         log.info("after invoking embedding_model service ")
+#         er=log_dict[request_id_var.get()]
+#         logobj = {"_id":id,"error":er}
+#         if len(er)!=0:
+#             log.debug(str(logobj))
+#         del log_dict[id]
+#         # log.debug("response : " + str(response))
+#         # log.debug("response : " + str(response))
+#         log.info("exit embedding_model routing method")
+#         log.info(f"Time taken by Jailbreak {time.time()-st}")
+#         return jsonable_encoder(response)
+#     except Exception as cie:
+#         log.error(cie.__dict__)
+#         log.info("exit embedding_model routing method")
+#         raise HTTPException()
+    
+    

src/routing/safety_router.py

@@ -0,0 +1,53 @@
+'''
+Copyright 2024-2025 Infosys Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+from flask import Blueprint
+import time
+from flask import  request
+from werkzeug.exceptions import HTTPException
+# from service.safety_service import ImageGen
+import uuid
+from exception.exception import modeldeploymentException
+from config.logger import CustomLogger, request_id_var
+from io import BytesIO
+import base64
+
+
+img_router = Blueprint('img_router', __name__,)
+log=CustomLogger()
+
+request_id_var.set('startup')
+@img_router.post("/ImageGenerate")
+def img():
+    prompt = request.form.get("prompt")
+    st=time.time()
+    id=uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create usecase routing method")
+    try:
+        # log.info("before invoking create usecase service")
+        
+        # response = ImageGen.generate(prompt)
+        # log.info("after invoking create usecase service ")
+        
+        # log.debug("response : " + str(response))
+        log.info("exit create usecase routing method")
+        log.info(f"Time taken by toxicity {time.time()-st}")
+        imageByte=BytesIO()
+        response.save(imageByte, format="png")
+        imageByte=imageByte.getvalue()
+        
+        return base64.b64encode(imageByte).decode('utf-8')
+    except modeldeploymentException as cie:
+        log.error(cie.__dict__)
+        log.info("exit create usecase routing method")
+        raise HTTPException(**cie.__dict__)
+
+

src/service/safety_service.py

@@ -0,0 +1,35 @@
+'''
+Copyright 2024-2025 Infosys Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+
+from diffusers import StableDiffusionPipeline
+import torch
+
+
+# model_name = "../models/stable_diffusion_v_1_5"
+if(torch.cuda.is_available()):
+    pipe = StableDiffusionPipeline.from_pretrained(model_name,torch_dtype=torch.float16,safety_checker=None)
+    inference=50
+    device = torch.device("cuda")
+    pipe=pipe.to(device)
+
+else:
+    pipe = StableDiffusionPipeline.from_pretrained(model_name,safety_checker=None)
+    inference=2
+
+class ImageGen:
+    def generate(prompt):
+        try:
+            image = pipe(prompt,num_inference_steps=inference).images[0]
+            # image.show()
+            return image
+        except Exception as e:
+            
+            raise Exception("Error in generating image")
+        

src/service/service.py

@@ -0,0 +1,364 @@
+import os
+'''
+Copyright 2024-2025 Infosys Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+'''
+import multiprocessing
+import threading
+
+import math
+import torch
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+from sentence_transformers import SentenceTransformer,util
+from detoxify import Detoxify
+#from presidio_analyzer import AnalyzerEngine, RecognizerRegistry
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, pipeline
+from werkzeug.exceptions import InternalServerError
+from fastapi.encoders import jsonable_encoder
+import traceback
+from mapper.mapper import *
+import time
+import contextvars
+from config.logger import CustomLogger,request_id_var
+from privacy.privacy import Privacy as ps
+
+log = CustomLogger()
+
+import sys
+import os
+
+try:
+    if getattr(sys, 'frozen', False):
+        application_path = sys._MEIPASS
+    else:
+        application_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..')
+        
+    log=CustomLogger()
+    log.info("before loading model")
+    request_id_var = contextvars.ContextVar("request_id_var")
+    #pipe = StableDiffusionPipeline.from_pretrained('/model/stablediffusion/fp32/model')
+    device = "cuda"
+#    registry = RecognizerRegistry()
+#    registry.load_predefined_recognizers()
+#    analyzer_engine = AnalyzerEngine(registry=registry)
+
+    device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+    print("device",device)
+    gpu=0 if torch.cuda.is_available() else -1
+    # BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    # # for i in os.walk(BASE_DIR)
+    # print(BASE_DIR)
+    # print(os.listdir(BASE_DIR))
+    # print(os.listdir())
+    check_point = 'toxic_debiased-c7548aa0.ckpt'
+    toxicityModel = Detoxify(checkpoint=os.path.join(application_path, 'models/detoxify/'+ check_point),
+                        device=device,
+                        huggingface_config_path=os.path.join(application_path, 'models/detoxify'))
+    tokenizer = AutoTokenizer.from_pretrained(os.path.join(application_path, "models/detoxify"))
+
+
+    PromptModel_dberta = AutoModelForSequenceClassification.from_pretrained(os.path.join(application_path, "models/dbertaInjection")).to(device)
+    Prompttokens_dberta = AutoTokenizer.from_pretrained(os.path.join(application_path, "models/dbertaInjection"))
+    promtModel = pipeline("text-classification", model=PromptModel_dberta, tokenizer=Prompttokens_dberta, device=device)
+
+    #topictokenizer_Facebook = AutoTokenizer.from_pretrained("../models/facebook")
+    #topicmodel_Facebook = AutoModelForSequenceClassification.from_pretrained("../models/facebook").to(device)
+
+    topictokenizer_dberta = AutoTokenizer.from_pretrained(os.path.join(application_path,"models/restricted-dberta-base-zeroshot-v2"))
+    topicmodel_dberta = AutoModelForSequenceClassification.from_pretrained(os.path.join(application_path,"models/restricted-dberta-base-zeroshot-v2")).to(device)
+    nlp = pipeline('zero-shot-classification', model=topicmodel_dberta, tokenizer=topictokenizer_dberta,device=gpu)
+    # classifier = pipeline("zero-shot-classification",model="../../models/facebook",device=device)
+    # classifier2 = pipeline("zero-shot-classification",model="../../models/restricted-dberta-large-zeroshot",device=device)
+    encoder = SentenceTransformer(os.path.join(application_path, "models/multi-qa-mpnet-base-dot-v1")).to(device)
+
+    jailbreakModel = encoder
+    similarity_model =encoder
+    request_id_var.set("Startup")
+    log_dict={}
+    log.info("model loaded")
+
+except Exception as e:
+    log.error(f"Exception: {e}")
+    log.error(f"Exception: {str(traceback.extract_tb(e.__traceback__)[0].lineno),e}")
+
+def privacy(id,text):  
+    log.info("inside privacy")
+    
+    try:
+        st = time.time()
+        res=ps.textAnalyze({"inputText":text,
+                    "account": None,
+                    "portfolio":None,
+                    "exclusionList": None,
+                    "piiEntitiesToBeRedacted":None,
+                    "nlp":None,
+                    "fakeData": "false"})
+        et = time.time()
+        rt = et-st
+        #print("result start",res.PIIEntities,"result end", "time",rt)
+        
+        # output['PIIresult'] = {"PIIresult":res.PIIEntities,"modelcalltime":round(rt,3)}
+        return {"PIIresult":res.PIIEntities,"modelcalltime":round(rt,3)}
+    except Exception as e:
+             
+            log.error("Error occured in privacy")
+            log.error(f"Exception: {str(traceback.extract_tb(e.__traceback__)[0].lineno),e}")
+            log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+                                                   "Error Module":"Failed at privacy call"})
+            raise InternalServerError()
+
+def multi_q_net_similarity(id,text1=None,text2=None,emb1=None,emb2=None):
+    
+    try:
+        st = time.time()
+        if text1:
+            with torch.no_grad():
+                emb1 = jailbreakModel.encode(text1, convert_to_tensor=True,device=device)
+        if text2:
+            with torch.no_grad():
+                emb2 = jailbreakModel.encode(text2, convert_to_tensor=True,device=device)
+        
+        emb = util.pytorch_cos_sim(emb1, emb2).to("cpu").numpy().tolist()
+        del emb1
+        del emb2
+        et = time.time()
+        rt =et-st
+        return emb,{'time_taken': str(round(rt,3))+"s"}
+    except Exception as e:
+             
+            log.error("Error occured in multi_q_net_similarity")
+            log.error(f"Exception: {str(traceback.extract_tb(e.__traceback__)[0].lineno),e}")
+            log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+                                                   "Error Module":"Failed at multi_q_net_similarity call"})
+            raise InternalServerError()
+            
+def multi_q_net_embedding(id,lst):
+    log.info("inside multi_q_net_embedding")
+    
+    try:
+        st = time.time()
+        # print("start time JB===========",lst,st)
+        
+        res = []
+        for text in lst:
+            with torch.no_grad():
+                text_embedding = jailbreakModel.encode(text, convert_to_tensor=True,device=device)
+            res.append(text_embedding.to("cpu").numpy().tolist())
+
+        del text_embedding
+        et = time.time()
+        rt = et-st
+        # output['multi_q_net_embedding'] =(res,{'time_taken': str(round(rt,3))+"s"})
+        return res,{'time_taken': str(round(rt,3))+"s"}
+        # return output
+        # return text_embedding.numpy().tolist()
+    except Exception as e:
+             
+            log.error("Error occured in multi_q_net text embedding")
+            log.error(f"Exception: {str(traceback.extract_tb(e.__traceback__)[0].lineno),e}")
+            log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+                                                   "Error Module":"Failed at multi_q_net text embedding call"})
+            raise InternalServerError()
+            
+def restricttopic_check(payload,id): 
+    log.info("inside restricttopic_check")
+    
+    try:
+        st = time.time()
+        # topicmodel = topicmodel_Facebook
+        # topictokenizer = topictokenizer_Facebook
+
+        # nlp = pipeline('zero-shot-classification', model=classifier, tokenizer=topictokenizer)
+
+        text=payload['text']
+        labels=payload['labels']
+        hypothesis_template = "The topic of this text is {}"
+        #commented to use just dberta model
+        #model =payload['model'] if hasattr(payload, 'model') else "facebook"
+        #if model==None:
+        #    model="dberta"
+        
+        # if model=="facebook":
+        #     # nlp = classifier
+        #     nlp = pipeline('zero-shot-classification', model=topicmodel_Facebook, tokenizer=topictokenizer_Facebook, device=gpu)
+        # elif model=="dberta": 
+        #     # nlp = classifier2
+        #     nlp = pipeline('zero-shot-classification', model=topicmodel_dberta, tokenizer=topictokenizer_dberta,device=gpu)
+        nlp = pipeline('zero-shot-classification', model=topicmodel_dberta, tokenizer=topictokenizer_dberta,device=gpu)
+        with torch.no_grad():    
+            output=nlp(text, labels,hypothesis_template=hypothesis_template,multi_label=True)
+
+        for i in range(len(output["scores"])):
+            output["scores"][i] = round(output["scores"][i],4)
+
+        del nlp
+        et = time.time()
+        rt = et-st
+        output['time_taken'] = str(round(rt,3))+"s"
+        # output1['restricttopic'] = output
+        return output
+    
+    except Exception as e:
+             
+            log.error("Error occured in restricttopic_check")
+            log.error(f"Exception: {str(traceback.extract_tb(e.__traceback__)[0].lineno),e}")
+            log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+                                                   "Error Module":"Failed at restricttopic_check call"})
+            raise InternalServerError()
+
+def toxicity_check(payload,id) :
+    log.info("inside toxicity_check")
+    
+    try:
+        st = time.time()
+        text = payload['text']
+
+        #to check number of tokens 
+        input_ids_val = tokenizer.encode(text)
+        input_ids=input_ids_val[1:-1]
+        result_list=[]
+        #to send max 510 tokens to the model at a time and at end find avg result for each token set
+        if len(input_ids)>510:
+            val=math.ceil(len(input_ids)/510)
+            j=0
+            k=510
+            for i in range(0,val):
+                text="".join(tokenizer.decode(input_ids[j:k]))
+                j+=510
+                k+=510
+                with torch.no_grad():
+                    result = toxicityModel.predict(text)
+                    result_list.append(result)
+            output = {
+                'toxicity': 0,
+                'severe_toxicity': 0,
+                'obscene': 0,
+                'threat': 0,
+                'insult': 0,
+                'identity_attack': 0,
+                'sexual_explicit': 0
+                }
+            for j in result_list:
+                 output['toxicity']+=j['toxicity']
+                 output['severe_toxicity']+=j['severe_toxicity']
+                 output['obscene']+=j['obscene']
+                 output['identity_attack']+=j['identity_attack']
+                 output['insult']+=j['insult']
+                 output['threat']+=j['threat']
+                 output['sexual_explicit']+=j['sexual_explicit']
+            output = {k: v / len(result_list) for k, v in output.items()}
+        else:
+            with torch.no_grad():
+                output = toxicityModel.predict(text)
+        List_profanity_score = []
+        obj_profanityScore_toxic = profanityScore(metricName='toxicity',
+                                        metricScore=output['toxicity'])
+        obj_profanityScore_severe_toxic = profanityScore(metricName='severe_toxicity',
+                                        metricScore=output['severe_toxicity'])
+        obj_profanityScore_obscene = profanityScore(metricName='obscene',
+                                        metricScore=output['obscene'])
+        obj_profanityScore_threat = profanityScore(metricName='threat',
+                                        metricScore=output['threat'])
+        obj_profanityScore_insult = profanityScore(metricName='insult',
+                                        metricScore=output['insult'])
+        obj_profanityScore_identity_attack = profanityScore(metricName='identity_attack',
+                                        metricScore=output['identity_attack'])
+        obj_profanityScore_sexual_explicit = profanityScore(metricName='sexual_explicit',
+                                        metricScore=output['sexual_explicit'])
+        
+        List_profanity_score.append(obj_profanityScore_toxic)
+        List_profanity_score.append(obj_profanityScore_severe_toxic)
+        List_profanity_score.append(obj_profanityScore_obscene)
+        List_profanity_score.append(obj_profanityScore_threat)
+        List_profanity_score.append(obj_profanityScore_insult)
+        List_profanity_score.append(obj_profanityScore_identity_attack)
+        List_profanity_score.append(obj_profanityScore_sexual_explicit)
+
+        objProfanityAnalyzeResponse = {}
+        objProfanityAnalyzeResponse['toxicScore'] = List_profanity_score
+        et = time.time()
+        rt = et-st
+        objProfanityAnalyzeResponse['time_taken'] = str(round(rt,3))+"s"
+        # output1['toxicity'] = objProfanityAnalyzeResponse
+        return objProfanityAnalyzeResponse
+    
+    except Exception as e:
+             
+            log.error("Error occured in toxicity_check")
+            log.error(f"Exception: {str(traceback.extract_tb(e.__traceback__)[0].lineno),e}")
+            log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+                                                   "Error Module":"Failed at toxicity_check call"})
+            raise InternalServerError()
+              
+def promptInjection_check(text,id):
+    
+    log.info("inside promptInjection_check")
+    try:
+        st = time.time()
+        result = promtModel(text)
+        # print("============:",result)
+        predicted_label_name = result[0]["label"]
+        predicted_probabilities = result[0]["score"]
+        # del tokens
+        et = time.time()
+        rt = et-st
+        # output['promptInjection'] = (predicted_label_name,predicted_probabilities, {'time_taken':str(round(rt,3))+"s"})
+        
+        return predicted_label_name,predicted_probabilities, {'time_taken':str(round(rt,3))+"s"}
+    except Exception as e:
+            
+            log.error("Error occured in promptInjection_check")
+            log.error(f"Exception: {str(traceback.extract_tb(e.__traceback__)[0].lineno),e}")
+            log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+                                                   "Error Module":"Failed at promptInjection_check call"})
+            raise InternalServerError()
+        
+# def checkall(id,payload):
+#     try:
+#         st = time.time()
+#         output = {}
+#         x=[]
+#         threads = []
+#         results = []
+#         thread = threading.Thread(target=toxicity_check, args=(payload['text'],id,output))
+#         threads.append(thread)
+#         thread.start()
+#         thread1 = threading.Thread(target=promptInjection_check, args=(payload['text']['text'],id,output))
+#         threads.append(thread1)
+#         thread1.start()
+#         thread2 = threading.Thread(target=restricttopic_check, args=(payload["restric"],id,output))
+#         threads.append(thread2)
+#         thread2.start()
+#         thread3 = threading.Thread(target=multi_q_net_embedding, args=(id,payload['embed']["text"],output))
+#         threads.append(thread3)
+#         thread3.start()
+#         thread4 = threading.Thread(target=privacy, args=(id,payload['text']['text'],output))
+#         threads.append(thread4)
+#         thread4.start()
+#         for thread in threads:
+#             thread.join()
+#             # print("=======================:",result)
+#             # results.append(thread.result)
+#         # with multiprocessing.Pool() as pool:
+#         #     output['toxicity'] =pool.starmap(toxicity_check, [(payload["text"],id)])
+#         #     output['promptInjection'] = pool.starmap(promptInjection_check, [(payload['text'],id)])
+#         #     output['restricttopic'] = pool.starmap(restricttopic_check, [(payload["restric"],id)])
+#         #     output['multi_q_net_embedding'] = pool.starmap(multi_q_net_embedding, [(id,payload['embed']["text"])])
+#         #     output['privacy'] = pool.starmap(privacy, [(id,payload['text'])])
+#         # print("output",output)
+#         et = time.time()
+#         rt = et-st
+#         output['time_taken'] = str(round(rt,3))+"s"
+#         return output
+#     except Exception as e:
+            
+#             log.error("Error occured in checkall")
+#             log.error(f"Exception: {str(traceback.extract_tb(e.__traceback__)[0].lineno),e}")
+#             log_dict[request_id_var.get()].append({"Line number":str(traceback.extract_tb(e.__traceback__)[0].lineno),"Error":str(e),
+#                                                    "Error Module":"Failed at checkall call"})
+#             raise InternalServerError()

src/static/swagger.json

@@ -0,0 +1,710 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "Infosys Responsible AI - LLM Moderation Models - OpenAPI 3.0",
+    "description": "API specs for Infosys Responsible AI LLM Moderation layer Models in OpenAPI 3.0 format",
+    "contact": {
+      "email": "[email protected]"
+    },
+    "license": {
+      "name": "Infosys",
+      "url": "https://www.infosys.com"
+    },
+    "version": "0.0.1"
+  },
+  "security" : [ {
+      "oauth_auth" : [ "write:users", "read:users" ]
+      } 
+  ],
+  "paths": {
+    "/rai/v1/raimoderationmodels/detoxifymodel": {
+      "post": {
+        "security": [{
+            "my_auth": ["write:users"]
+        }],
+        "tags": [
+          "Infosys Responsible AI - LLM Moderation"
+        ],
+        "summary": "Toxic Model",
+        "operationId": "toxic_model_rai_v1_models_detoxifymodel_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/detoxifyRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/detoxifyResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          },
+          "401":
+          {
+            "description":"Unauthorized Access Error",
+            "content":{
+              "application/json":{
+                "schema":{
+                  "$ref":"#/components/schemas/HTTPUnauthorizedAccessError"
+                }
+              }
+            }
+          },
+          "403":
+          {
+            "description":"Forbidden Access Error",
+            "content":{
+              "application/json":{
+                "schema":{
+                  "$ref":"#/components/schemas/HTTPForbiddenAccessError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/rai/v1/raimoderationmodels/privacy": {
+      "post": {
+        "security": [{
+            "my_auth": ["write:users"]
+        }],
+        "tags": [
+          "Infosys Responsible AI - LLM Moderation"
+        ],
+        "summary": "Pii Check",
+        "operationId": "pii_check_rai_v1_models_privacy_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/privacyRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          },
+          "401":
+          {
+            "description":"Unauthorized Access Error",
+            "content":{
+              "application/json":{
+                "schema":{
+                  "$ref":"#/components/schemas/HTTPUnauthorizedAccessError"
+                }
+              }
+            }
+          },
+          "403":
+          {
+            "description":"Forbidden Access Error",
+            "content":{
+              "application/json":{
+                "schema":{
+                  "$ref":"#/components/schemas/HTTPForbiddenAccessError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/rai/v1/raimoderationmodels/promptinjectionmodel": {
+      "post": {
+        "security": [{
+            "my_auth": ["write:users"]
+        }],
+        "tags": [
+          "Infosys Responsible AI - LLM Moderation"
+        ],
+        "summary": "Prompt Model",
+        "operationId": "prompt_model_rai_v1_models_promptinjectionmodel_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/detoxifyRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          },
+          "401":
+          {
+            "description":"Unauthorized Access Error",
+            "content":{
+              "application/json":{
+                "schema":{
+                  "$ref":"#/components/schemas/HTTPUnauthorizedAccessError"
+                }
+              }
+            }
+          },
+          "403":
+          {
+            "description":"Forbidden Access Error",
+            "content":{
+              "application/json":{
+                "schema":{
+                  "$ref":"#/components/schemas/HTTPForbiddenAccessError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/rai/v1/raimoderationmodels/restrictedtopicmodel": {
+      "post": {
+        "security": [{
+            "my_auth": ["write:users"]
+        }],
+        "tags": [
+          "Infosys Responsible AI - LLM Moderation"
+        ],
+        "summary": "Restrictedtopic Model",
+        "operationId": "restrictedTopic_model_rai_v1_models_restrictedtopicmodel_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/RestrictedTopicRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          },
+          "401":
+          {
+            "description":"Unauthorized Access Error",
+            "content":{
+              "application/json":{
+                "schema":{
+                  "$ref":"#/components/schemas/HTTPUnauthorizedAccessError"
+                }
+              }
+            }
+          },
+          "403":
+          {
+            "description":"Forbidden Access Error",
+            "content":{
+              "application/json":{
+                "schema":{
+                  "$ref":"#/components/schemas/HTTPForbiddenAccessError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/rai/v1/raimoderationmodels/multi_q_net_embedding": {
+      "post": {
+        "security": [{
+            "my_auth": ["write:users"]
+        }],
+        "tags": [
+          "Infosys Responsible AI - LLM Moderation"
+        ],
+        "summary": "Embedding Model",
+        "operationId": "embedding_model_rai_v1_models_multi_q_net_embedding_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/JailbreakRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          },
+          "401":
+          {
+            "description":"Unauthorized Access Error",
+            "content":{
+              "application/json":{
+                "schema":{
+                  "$ref":"#/components/schemas/HTTPUnauthorizedAccessError"
+                }
+              }
+            }
+          },
+          "403":
+          {
+            "description":"Forbidden Access Error",
+            "content":{
+              "application/json":{
+                "schema":{
+                  "$ref":"#/components/schemas/HTTPForbiddenAccessError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/rai/v1/raimoderationmodels/multi-qa-mpnet-model_similarity": {
+      "post": {
+        "security": [{
+            "my_auth": ["write:users"]
+        }],
+        "tags": [
+          "Infosys Responsible AI - LLM Moderation"
+        ],
+        "summary": "Similarity Model",
+        "operationId": "similarity_model_rai_v1_models_multi_qa_mpnet_model_similarity_post",
+        "parameters": [
+          {
+            "required": false,
+            "schema": {
+              "type": "string",
+              "title": "Authorization"
+            },
+            "name": "authorization",
+            "in": "header"
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/SimilarityRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          },
+          "401":
+          {
+            "description":"Unauthorized Access Error",
+            "content":{
+              "application/json":{
+                "schema":{
+                  "$ref":"#/components/schemas/HTTPUnauthorizedAccessError"
+                }
+              }
+            }
+          },
+          "403":
+          {
+            "description":"Forbidden Access Error",
+            "content":{
+              "application/json":{
+                "schema":{
+                  "$ref":"#/components/schemas/HTTPForbiddenAccessError"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "HTTPValidationError": {
+        "properties": {
+          "detail": {
+            "items": {
+              "$ref": "#/components/schemas/ValidationError"
+            },
+            "type": "array",
+            "title": "Detail"
+          }
+        },
+        "type": "object",
+        "title": "HTTPValidationError"
+      },
+      "HTTPUnauthorizedAccessError":{
+       "properties":{
+        "detail":{
+          "items":{
+            "$ref":"#/components/schemas/UnauthorizedAccessError"
+          },
+          "type":"array",
+          "title":"Detail"
+        }
+       },
+       "type":"object",
+       "title":"HTTPUnauthorizedAccessError"
+      },
+      "HTTPForbiddenAccessError":{
+       "properties":{
+        "detail":{
+          "items":{
+            "$ref":"#/components/schemas/ForbiddenAccessError"
+          },
+          "type":"array",
+          "title":"Detail"
+        }
+       },
+       "type":"object",
+       "title":"HTTPForbiddenAccessError" 
+      },
+      "JailbreakRequest": {
+        "properties": {
+          "text": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array",
+            "title": "Text"
+          }
+        },
+        "type": "object",
+        "required": [
+          "text"
+        ],
+        "title": "JailbreakRequest"
+      },
+      "RestrictedTopicRequest": {
+        "properties": {
+          "text": {
+            "type": "string",
+            "title": "Text",
+            "example": "Russia is the biggest country by area."
+          },
+          "labels": {
+            "items": {},
+            "type": "array",
+            "title": "Labels",
+            "default": [
+              "Terrorism",
+              "Explosives"
+            ]
+          }
+        },
+        "type": "object",
+        "required": [
+          "text"
+        ],
+        "title": "RestrictedTopicRequest"
+      },
+      "SimilarityRequest": {
+        "properties": {
+          "text1": {
+            "type": "string",
+            "title": "Text1",
+            "example": "Russia is the biggest country by area."
+          },
+          "text2": {
+            "type": "string",
+            "title": "Text2",
+            "example": "Russia is the biggest country by area."
+          },
+          "emb1": {
+            "items": {},
+            "type": "array",
+            "title": "Emb1"
+          },
+          "emb2": {
+            "items": {},
+            "type": "array",
+            "title": "Emb2"
+          }
+        },
+        "type": "object",
+        "title": "SimilarityRequest"
+      },
+      "ValidationError": {
+        "properties": {
+          "loc": {
+            "items": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "integer"
+                }
+              ]
+            },
+            "type": "array",
+            "title": "Location"
+          },
+          "msg": {
+            "type": "string",
+            "title": "Message"
+          },
+          "type": {
+            "type": "string",
+            "title": "Error Type"
+          }
+        },
+        "type": "object",
+        "required": [
+          "loc",
+          "msg",
+          "type"
+        ],
+        "title": "ValidationError"
+      },
+      "UnauthorizedAccessError":{
+        "properties": {
+          "loc": {
+            "items": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "integer"
+                }
+              ]
+            },
+            "type": "array",
+            "title": "Location"
+          },
+          "msg": {
+            "type": "string",
+            "title": "Message"
+          },
+          "type": {
+            "type": "string",
+            "title": "Error Type"
+          }
+        },
+        "type": "object",
+        "required": [
+          "loc",
+          "msg",
+          "type"
+        ],
+        "title": "UnauthorizedAccessError"
+      },
+      "ForbiddenAccessError":{
+        "properties": {
+          "loc": {
+            "items": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "integer"
+                }
+              ]
+            },
+            "type": "array",
+            "title": "Location"
+          },
+          "msg": {
+            "type": "string",
+            "title": "Message"
+          },
+          "type": {
+            "type": "string",
+            "title": "Error Type"
+          }
+        },
+        "type": "object",
+        "required": [
+          "loc",
+          "msg",
+          "type"
+        ],
+        "title": "ForbiddenAccessError"
+      },
+      "detoxifyRequest": {
+        "properties": {
+          "text": {
+            "type": "string",
+            "title": "Text",
+            "example": "Russia is the biggest country by area."
+          }
+        },
+        "type": "object",
+        "required": [
+          "text"
+        ],
+        "title": "detoxifyRequest"
+      },
+      "detoxifyResponse": {
+        "properties": {
+          "toxicScore": {
+            "items": {
+              "$ref": "#/components/schemas/profanityScore"
+            },
+            "type": "array",
+            "title": "Toxicscore"
+          }
+        },
+        "type": "object",
+        "required": [
+          "toxicScore"
+        ],
+        "title": "detoxifyResponse"
+      },
+      "privacyRequest": {
+        "properties": {
+          "text": {
+            "type": "string",
+            "title": "Text",
+            "example": "Russia is the biggest country by area."
+          }
+        },
+        "type": "object",
+        "required": [
+          "text"
+        ],
+        "title": "privacyRequest"
+      },
+      "profanityScore": {
+        "properties": {
+          "metricName": {
+            "type": "string",
+            "title": "Metricname",
+            "example": "toxicity"
+          },
+          "metricScore": {
+            "type": "number",
+            "title": "Metricscore",
+            "example": 0.78326
+          }
+        },
+        "type": "object",
+        "required": [
+          "metricName",
+          "metricScore"
+        ],
+        "title": "profanityScore"
+      }
+    },
+    "securitySchemes": {
+            "type": "oauth2",
+            "flows": {
+                "authorizationCode": {
+                    "authorizationUrl": "http://tes.org/api/oauth/dialog",
+                    "scopes": {
+                        "read:users": "read user profiles"
+                    }
+                }
+            }
+    }
+  },
+  "tags": [
+    {
+      "name": "LLM Moderation",
+      "description": "Operations required for LLM moderation proxy.",
+      "externalDocs": {
+        "description": "Find out more",
+        "url": "https://www.infosys.com"
+      }
+    }
+  ]
+}