Track large files and images with Git LFS

.gitattributes

@@ -33,3 +33,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+src/privacy/util/code_detect/ner/pii_inference/nermodel/pytorch_model.bin filter=lfs diff=lfs merge=lfs -text
+src/privacy/util/face_detect/face_detector/res10_300x300_ssd_iter_140000.caffemodel filter=lfs diff=lfs merge=lfs -text
+src/privacy/util/model/craft_mlt_25k.pth filter=lfs diff=lfs merge=lfs -text
+src/privacy/util/model/english_g2.pth filter=lfs diff=lfs merge=lfs -text
+src/privacy/util/face_detect/doc/10.jpg filter=lfs diff=lfs merge=lfs -text
+src/privacy/util/face_detect/doc/5.jpg filter=lfs diff=lfs merge=lfs -text
+src/privacy/util/face_detect/doc/8.jpg filter=lfs diff=lfs merge=lfs -text
+src/privacy/util/face_detect/doc/*.jpg filter=lfs diff=lfs merge=lfs -text

src/.env

@@ -0,0 +1 @@
+FILE_NAME = "presidio_analyzer-3.0.0-py3-none-any.whl"

src/logger.ini

@@ -0,0 +1,5 @@
+[logDetails]
+LOG_LEVEL=DEBUG
+FILE_NAME=projectmanagementservicelogs
+VERBOSE=False
+LOG_DIR=/aicloud/logs

src/main.py

@@ -0,0 +1,141 @@
+'''
+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.
+'''
+from typing import List
+
+
+import uvicorn
+from privacy.config.logger import CustomLogger
+from privacy.config.config import read_config_yaml
+from fastapi import Depends, FastAPI, Request, Response
+from fastapi.exceptions import RequestValidationError
+from starlette.exceptions import HTTPException as StarletteHTTPException
+from privacy.routing.privacy_router import router
+# from starlette.middleware.cors import CORSMiddleware
+# from starlette.middleware import Middleware
+from fastapi.responses import JSONResponse, PlainTextResponse, Response
+from fastapi.middleware.cors import CORSMiddleware
+
+from aicloudlibs.utils.global_exception import UnSupportedMediaTypeException
+from aicloudlibs.utils import global_exception_handler
+
+
+log=CustomLogger()
+## initialize the app with openapi and docs url
+
+## reading metadata configuration from config file
+
+
+
+app = FastAPI(**read_config_yaml('../config/metadata.yaml'))
+
+"""
+
+    Adding the CORS Middleware which handles the requests from different origins
+
+    allow_origins - A list of origins that should be permitted to make cross-origin requests.
+                    using ['*'] to allow any origin
+    allow_methods - A list of HTTP methods that should be allowed for cross-origin requests.
+                    using ['*'] to allow all standard method
+    allow_headers - A list of HTTP request headers that should be supported for cross-origin requests. 
+                    using ['*'] to allow all headers
+"""
+
+# origins = [
+#     'http://10.66.155.13',
+#     'http://10.66.155.13:30010',
+
+# ]
+
+
+app.add_middleware(
+     CORSMiddleware,
+     allow_origins=["*"],
+     allow_credentials=True,
+     allow_methods=["*"],
+     allow_headers=["*"]
+ )
+
+"""
+FAST API raise RequestValidationError in case request contains invalid data.
+A global exception handler function to handle the requests which contains the invalid data
+
+"""
+
+# @app.options("/{rest_of_path:path}")
+# async def preflight_handler(request: Request, rest_of_path: str) -> Response:
+#     """
+#     Handles OPTIONS requests to /*.
+#     """
+#     response = Response()
+#     response.headers["Access-Control-Allow-Origin"] = "*"
+#     response.headers["Access-Control-Allow-Methods"] = "POST, GET, DELETE, PATCH, OPTIONS"
+#     response.headers["Access-Control-Allow-Headers"] = "Authorization, Content-Type"
+#     return response
+
+# @app.middleware("http")
+# async def add_cors_header(request , call_next):
+#    """
+#    Sets CORS headers.
+#   """
+#   response = await call_next(request)
+#   response.headers["Access-Control-Allow-Origin"] = "http://10.66.155.13:30010"
+#  response.headers["Access-Control-Allow-Credentials"] = "true"
+#   response.headers["Access-Control-Allow-Methods"] = "GET, POST, PUT, DELETE, OPTIONS"
+#   response.headers["Access-Control-Allow-Headers"] = "Content-Type, Authorization"
+#    return response
+
+# origins = [
+#   "http://10.66.155.13",
+#   "http://10.66.155.13:30010",
+# ]
+
+# app.add_middleware(
+#    CORSMiddleware,
+#    allow_origins=origins,
+#    allow_credentials=True,
+#   allow_methods=["*"],
+#    allow_headers=["*"],
+# )
+
+
+
+
+
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    return  global_exception_handler.validation_error_handler(exc)
+
+
+"""
+A global exception handler function to handle the unsupported media type exception
+"""
+@app.exception_handler(UnSupportedMediaTypeException)
+async def unsupported_mediatype_error_handler(request: Request, exc: UnSupportedMediaTypeException):
+    return  global_exception_handler.unsupported_mediatype_error_handler(exc)
+
+
+
+"""
+A global exception handler function to handle the http exception
+"""
+@app.exception_handler(StarletteHTTPException)
+async def http_exception_handler(request, exc):
+     return  global_exception_handler.http_exception_handler(exc)
+
+
+
+"""
+incude the routing details of service
+"""
+
+app.include_router(router, prefix='/v1', tags=["PII Privacy"])
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=30002)

src/privacy/.env

@@ -0,0 +1,26 @@
+# PRIVADMIN_API = "${admin}"
+# PRIVADMIN_API = "http://localhost:8080"
+# PRIVADMIN_API = "http://10.66.155.13:30016"
+ISDB=False
+
+
+# PRIVADMIN_API= "http://localhost:8080/api/v1/rai/admin/PrivacyDataList"
+en_core_web_lg={"lang_code": "en", "model_name": "en_core_web_lg"}
+en_core_web_trf={"lang_code": "en", "model_name": "en_core_web_trf"}
+PRIVACY_TELEMETRY_URL = "${privacytelemetryurl}"
+PRIVACY_ERROR_URL = "${privacyerrorurl}"
+PRIVADMIN_API="${adminapi}"
+
+
+AUTH_TYPE = none          # Options: azure , jwt , none
+SECRET_KEY = "${secretkey}"        # Secret key for JWT token
+AZURE_CLIENT_ID="${azureclientid}"
+AZURE_TENANT_ID="${azuretenantid}"
+AZURE_AD_JWKS_URL = "${azuread_jwks_url}"
+
+TELE_FLAG="False"
+ADMIN_CONNECTION="False"
+API_KEY="${api_key}"
+API_ENDPOINT="${api_endpoint}"
+GCS_DEVELOPER_KEY="${gcsdeveloperkey}"
+

src/privacy/code_generator/codegeneration.py

@@ -0,0 +1,257 @@
+'''
+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.
+'''
+
+import os
+import subprocess
+import shutil
+# from dotenv import load_dotenv
+# load_dotenv()
+
+# def test():
+#     print(os.environ)
+#     #test = os.environ["FILE_NAME"]
+#     #print(test)
+    
+#     print(os.getenv('FILE_NAME'))
+
+
+# FILE CREATION
+def create_new_recognizer_file(file_name, regex_expression):
+    template_file = "template_recognizer.py"  # Assign the template file name directly
+    # Get the absolute path of the current script's directory
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    # print(script_dir)
+    # Construct the full path to the template file
+    template_file_path = os.path.join(script_dir, template_file)
+    #output file path
+    # output_directory = os.path.join(script_dir, "..\\..\\..\\..\\presidio_analyzer\\presidio_analyzer\\Infosys_presidio_analyzer\\presidio_analyzer\\presidio_analyzer\\predefined_recognizers")
+    output_directory = "../../presidio_analyzer/presidio_analyzer/Infosys_presidio_analyzer/presidio_analyzer/presidio_analyzer/predefined_recognizers/"
+    os.makedirs(output_directory, exist_ok=True)
+    #new file name
+    new_file = f"{file_name}_recognizer.py"
+    #combine the path
+    output_path = os.path.join(output_directory, new_file)
+    with open(template_file_path, "r") as f:
+        template_content = f.read()
+
+    # Replace the placeholder values in the template
+    # have to start replacing the content in the template file
+    # Replace the class name in the template
+    new_content = template_content.replace("Class_Name", file_name)
+    # Replace the supported_entity parameter value
+    supported_entity = file_name.upper()
+    new_content = new_content.replace('supported_entity: str = "AADHAR_NUMBER"',
+                                      f'supported_entity: str = "{supported_entity}"')
+    # Replacing the pattern name
+    new_content = new_content.replace("pattern_name", f"{file_name.lower()}_pattern")
+    
+    # Replacing the regex expression
+    new_content = new_content.replace("REGEX_PATTERN", regex_expression)
+   # Write the modified content to the new file at the specified output path
+    with open(output_path, "w") as f:
+        f.write(new_content)
+    print(f"Created new recognizer file: {new_file}")
+    
+# ADDING IMPORTS IN RECOGNIZERS REGISTRY
+
+def modify_recognizer_registry(file_name):
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    recognizer_registry_file = os.path.join(
+        script_dir,
+        "../../../../presidio_analyzer/presidio_analyzer/Infosys_presidio_analyzer/presidio_analyzer/presidio_analyzer/recognizer_registry/recognizer_registry.py",
+    )
+
+    # Check if the class name is already imported
+    with open(recognizer_registry_file, "r") as f:
+        lines = f.readlines()
+    
+    class_name = f"class {file_name}"
+    existing_lines = [line.strip().lower() for line in lines]
+    new_import_line = f"    {file_name},"
+
+    # Check if the class name is already imported
+    is_imported = any(class_name.lower() == line.lower().strip() for line in existing_lines)
+
+    # If the class name is already imported, skip the addition
+    if is_imported:
+        print(f"Skipping addition: Import for {file_name} already exists")
+        return
+
+    # Find the position to insert the new import line
+    import_section_start = existing_lines.index("from presidio_analyzer.predefined_recognizers import (") + 1
+    import_section_end = existing_lines.index(")", import_section_start)
+    
+    en_section_start = lines.index("            \"en\": [\n")  # Find the start of the 'en' section
+    en_section_end = lines.index("            ],\n", en_section_start)  # Find the end of the 'en' section
+    
+    # Check if the import statement already exists in the 'en' section
+    is_imported_en = any(file_name.lower() in line.lower().strip() for line in existing_lines[en_section_start:en_section_end])
+
+    # If the import statement already exists in the 'en' section, skip the addition
+    if is_imported_en:
+        print(f"Skipping addition: Import for {file_name} already exists in the 'en' section")
+        return
+
+    # Add the filename import to the 'en' section
+    lines.insert(en_section_end, f"                {file_name},\n")
+    # Insert the new import line before the closing parenthesis
+    lines.insert(import_section_end, new_import_line + "\n")
+
+    # Write the modified content back to the file
+    with open(recognizer_registry_file, "w") as f:
+        f.writelines(lines)
+
+    print(f"Modified recognizer_registry.py: Added import for {file_name}")
+
+
+# def modify_recognizer_registry(file_name):
+#     script_dir = os.path.dirname(os.path.abspath(__file__))
+#     recognizer_registry_file = os.path.join(script_dir, "../Packages/presidio_analyzer/presidio_analyzer/presidio_analyzer/presidio_analyzer/presidio_analyzer/recognizer_registry/recognizer_registry.py")
+
+#     # Check if the class name is already imported
+#     with open(recognizer_registry_file, "r") as f:
+#         lines = f.readlines()
+    
+    
+#     class_name = f"class {file_name}"
+#     existing_lines = [line.strip().lower() for line in lines]
+#     new_import_line = f"    {file_name},"
+    
+    
+#     # Check if the class name is already imported
+#     is_imported = any(class_name.lower() == line.lower().strip() for line in existing_lines)
+
+#     # If the class name is already imported, skip the addition
+#     if is_imported:
+#         print(f"Skipping addition: Import for {file_name} already exists")
+#         return
+
+#     # Find the position to insert the new import line
+#     import_section_start = existing_lines.index("from presidio_analyzer.predefined_recognizers import (") + 1
+#     import_section_end = existing_lines.index(")", import_section_start)
+#     en_section_start = lines.index("            \"en\": [\n")  # Find the start of the 'en' section
+#     en_section_end = lines.index("            ],\n", en_section_start)  # Find the end of the 'en' section
+#     # Add the filename import to the 'en' section
+#     lines.insert(en_section_end, f"                {file_name},\n")
+#     # Insert the new import line before the closing parenthesis
+#     lines.insert(import_section_end, new_import_line + "\n")
+
+#     # Write the modified content back to the file
+#     with open(recognizer_registry_file, "w") as f:
+#         f.writelines(lines)
+
+#     print(f"Modified recognizer_registry.py: Added import for {file_name}")
+    
+# Adding import in initpy of predefined recognizers
+
+def modify_init_py(file_name):
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    init_py_file = os.path.join(script_dir, "../../../../presidio_analyzer/presidio_analyzer/Infosys_presidio_analyzer/presidio_analyzer/presidio_analyzer/predefined_recognizers/__init__.py")
+
+    # Check if the import statement is already present
+    with open(init_py_file, "r") as f:
+        lines = f.readlines()
+
+    import_line = f"from .{file_name}_recognizer import {file_name}\n"
+
+    # Check if the import statement is already present, skip the addition
+    is_imported = any(import_line.strip() == line.strip() for line in lines)
+
+    if is_imported:
+        print(f"Skipping addition: Import for {file_name} already exists in __init__.py")
+        return
+
+   # Find the position to insert the new import line
+    import_section_end = next(i for i, line in enumerate(lines) if not line.startswith("from "))
+
+    # Insert the new import line after the last import statement
+    lines.insert(import_section_end + 1, import_line)
+    # Write the modified content back to the file
+    with open(init_py_file, "w") as f:
+        f.writelines(lines)
+
+    print(f"Modified __init__.py: Added import for {file_name}")
+
+    
+# MAKING OF WHEEL FILES
+
+
+import os
+
+def run_wheel_creation_commands():
+    
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    directory = os.path.join(script_dir, "../../../../presidio_analyzer/presidio_analyzer/Infosys_presidio_analyzer")
+    # Specify the directory where you want to run the commands
+    
+    # Change to the specified directory
+    os.chdir(directory)
+
+    # Command 1: pip install pyc_wheel build
+    command1 = "pip install pyc_wheel build"
+    subprocess.run(command1, shell=True, check=True)
+
+    # Command 2: python create_wheel_file.py
+    command2 = "python create_wheel_file.py"
+    subprocess.run(command2, shell=True, check=True)
+
+
+def copy_wheel_file():
+    script_dirsourcewheel = os.path.dirname(os.path.abspath(__file__))
+    script_dirdestinationwheel = os.path.dirname(os.path.abspath(__file__))
+    
+    source_directory = os.path.join(script_dirsourcewheel, "../../../../presidio_analyzer/presidio_analyzer/Infosys_presidio_analyzer")
+    # Get the path of the wheel file
+    source_wheel_file = os.path.join(source_directory, "dist", "presidio_analyzer-4.0.5-py3-none-any.whl")
+    
+    destination_directory = os.path.join(script_dirdestinationwheel, "../../../lib")
+    
+     # Get the path of the destination wheel file
+    destination_wheel_file = os.path.join(destination_directory, "presidio_analyzer-4.0.5-py3-none-any.whl")
+    
+    # Remove the destination wheel file if it already exists
+    if os.path.exists(destination_wheel_file):
+        os.remove(destination_wheel_file)
+
+     # Copy the wheel file to the destination directory
+    shutil.copy2(source_wheel_file, destination_wheel_file)
+
+    # Change to the destination directory
+    os.chdir(destination_directory)
+
+    # Uninstall the previous version of presidio_analyzer
+    uninstall_command = "pip uninstall -y presidio_analyzer-4.0.5-py3-none-any.whl"
+    subprocess.run(uninstall_command, shell=True, check=True)
+
+    # Install the new version of presidio_analyzer
+    install_command = "pip install presidio_analyzer-4.0.5-py3-none-any.whl"
+    subprocess.run(install_command, shell=True, check=True)
+
+    print("Wheel file copied and installed successfully.")
+
+
+# # Call the function with the specified directory
+# run_wheel_creation_commands(directory)
+
+
+    
+    
+
+
+
+
+    
+    
+
+
+
+
+
+

src/privacy/code_generator/template_recognizer.py

@@ -0,0 +1,56 @@
+'''
+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.
+'''
+
+from typing import Optional, List
+
+from presidio_analyzer import Pattern, PatternRecognizer
+
+
+class Class_Name(PatternRecognizer):
+    """
+    Recognizes US bank number using regex.
+
+    :param patterns: List of patterns to be used by this recognizer
+    :param context: List of context words to increase confidence in detection
+    :param supported_language: Language this recognizer supports
+    :param supported_entity: The entity this recognizer can detect
+    """
+
+    PATTERNS = [
+        Pattern(name="pattern_name", regex="REGEX_PATTERN", score=0.5),
+    ]
+
+    CONTEXT = [
+        "bank"
+        # Task #603: Support keyphrases: change to "checking account"
+        # as part of keyphrase change
+        "check",
+        "account",
+        "account#",
+        "acct",
+        "save",
+        "debit",
+    ]
+
+    def __init__(
+        self,
+        patterns: Optional[List[Pattern]] = None,
+        context: Optional[List[str]] = None,
+        supported_language: str = "en",
+        supported_entity: str = "Class_Name",
+    ):
+        patterns = patterns if patterns else self.PATTERNS
+        context = context if context else self.CONTEXT
+        super().__init__(
+            supported_entity=supported_entity,
+            patterns=patterns,
+            context=context,
+            supported_language=supported_language,
+        )

src/privacy/config/config.py

@@ -0,0 +1,36 @@
+'''
+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.
+'''
+
+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/privacy/config/logger.py

@@ -0,0 +1,221 @@
+'''
+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.
+'''
+
+import datetime
+import logging
+import os
+import sys
+
+import httpx
+from .config import readConfig
+import http
+import contextvars
+# from request_id_store import request_ids
+
+import uuid
+# class UserLogger(logging.getLoggerClass()):
+#     def makeRecord(self, name, level, fn, lno, msg, args, exc_info, func=None, extra=None, sinfo=None):
+#         if extra is None:
+#             extra = {}
+#         extra['user_id'] = self.user_id
+#         return super().makeRecord(name, level, fn, lno, msg, args, exc_info, func, extra, sinfo)
+request_ids=[]
+request_id_var = contextvars.ContextVar("request_id_var")
+
+class CustomLogger(logging.getLoggerClass()):
+    # UserLogger(__)
+
+    # def __init__(self, user_id):
+    #     self.user_id = user_id
+    #     super().__init__(self)
+    
+    # def makeRecord(self, name, level, fn, lno, msg, args, exc_info, func=None, extra=None, sinfo=None):
+    #     if extra is None:
+    #         extra = {}
+    #     print("self===",self)
+    #     extra['user_id'] = self.user_id
+    #     return super().makeRecord(name, level, fn, lno, msg, args, exc_info, func, extra, sinfo)
+    
+    for request_id in request_ids:
+        print("request_id400000000==========",request_id)
+    # print("logging.getLoggerClass()",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
+        """
+
+        # print("self=====",self)
+        # Create custom logger logging all five levels
+        BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        log_cfg_path = os.path.join(BASE_DIR, 'logger.ini')
+        # print("log_cfg_path======",log_cfg_path)
+        log_params = readConfig('logDetails', log_cfg_path)
+        # print("log_params======",log_params)
+
+        name = log_params['file_name']
+        # user_id = log_params['user_id']
+        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.stdout_handler.setFormatter(logging.Formatter('%(user_id)s'))
+        self.enable_console_output()
+        user_id=12345
+        # self.user_id =user_id
+        self.file_handler = None
+        if log_dir:
+            text="Hello WOrld"
+            # self.add_file_handler(text, log_dir)
+            # self.add_file_handler(user_id,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
+        # heloo = "h"
+        # print("self=====",self.user_id)
+        # print("log_dir======",user_id)
+        # UserLogger(__name__)
+        # CustomLogger.user_id = 1
+        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():
+        # print("request_ids186=========",request_ids)
+        request_id = request_id_var.get()
+        # print("request_id=========",request_id)
+      
+        
+        
+        return request_id
+
+    
+
+    def debug(self, msg, *args, **kwargs ):
+        self._custom_log(super().debug, msg,extra = {'user_id':CustomLogger.getSeesionId()}, *args, **kwargs)
+
+    def info(self, msg, *args, **kwargs):
+        self._custom_log(super().info, msg,extra = {'user_id':CustomLogger.getSeesionId()}, *args, **kwargs)
+
+    def warning(self, msg,user_id=None, *args, **kwargs):
+        self._custom_log(super().warning, msg,extra = {'user_id':CustomLogger.getSeesionId()}, *args, **kwargs)
+
+    def error(self, msg,user_id=None, *args, **kwargs):
+        self._custom_log(super().error, msg,extra = {'user_id':CustomLogger.getSeesionId()}, *args, **kwargs)
+
+    def critical(self, msg,user_id=None, *args, **kwargs):
+        self._custom_log(super().critical, msg,extra = {'user_id':CustomLogger.getSeesionId()}, *args, **kwargs)
+
+
+if __name__ == "__main__":
+    logger= CustomLogger()
+    

src/privacy/constants/local_constants.py

@@ -0,0 +1,21 @@
+'''
+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.
+'''
+
+"""
+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"

src/privacy/dao/AccDataGrpMappingDb.py

@@ -0,0 +1,75 @@
+'''
+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.
+'''
+
+import pymongo
+import datetime,time
+from privacy.dao.DatabaseConnection import DB
+from dotenv import load_dotenv
+from privacy.config.logger import CustomLogger
+
+load_dotenv()
+log = CustomLogger()
+
+class AttributeDict(dict):
+    __getattr__ = dict.__getitem__
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+mydb=DB.connect()
+
+
+class AccDataGrpDb:
+    mycol = mydb["AccDataGrp"]
+    def findOne(id):
+        values=AccDataGrpDb.mycol.find({"_id":id},{})[0]
+        # print(values)
+        values=AttributeDict(values)
+        return values
+    def findall(query):
+        value_list=[]
+        values=AccDataGrpDb.mycol.find(query,{})
+        for v in values:
+
+            v=AttributeDict(v)
+            value_list.append(v)
+        return value_list
+    def create(value):
+         value=AttributeDict(value)
+         localTime = time.time()
+         mydoc = {
+        "_id":localTime,
+        "accMasterId":value.Aid,
+        "dataRecogGrpId":value.Did,
+        "isActive":"Y",
+        "isHashify":False,
+        "isCreated":"Not Started",
+        "CreatedDateTime": datetime.datetime.now(),
+        "LastUpdatedDateTime": datetime.datetime.now(),
+         }
+         PtrnRecogCreatedData = AccDataGrpDb.mycol.insert_one(mydoc)
+         return PtrnRecogCreatedData.acknowledged
+    
+    def update(query,value:dict):
+        
+        newvalues = { "$set": value }
+        
+        PtrnRecogUpdatedData=AccDataGrpDb.mycol.update_one(query,newvalues)
+        log.debug(str(newvalues)) 
+        return PtrnRecogUpdatedData.acknowledged
+    
+    def delete(id):
+        return AccDataGrpDb.mycol.delete_many({"dataRecogGrpId":id}).acknowledged
+        # DocProcDtl.mycol.delete_many({})
+        # Docpagedtl.mycol.delete_many({})
+    def deleteMany(query):
+        return AccDataGrpDb.mycol.delete_many(query).acknowledged
+    
+    

src/privacy/dao/AccMasterDb.py

@@ -0,0 +1,73 @@
+'''
+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.
+'''
+
+import pymongo
+import datetime,time
+from privacy.dao.DatabaseConnection import DB
+from dotenv import load_dotenv
+from privacy.config.logger import CustomLogger
+
+load_dotenv()
+log = CustomLogger()
+
+class AttributeDict(dict):
+    __getattr__ = dict.__getitem__
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+mydb=DB.connect()
+
+
+class AccMasterDb:
+    mycol = mydb["AccMaster"]
+    def findOne(id):
+        values=AccMasterDb.mycol.find({"_id":id},{})[0]
+        # print(values)
+        values=AttributeDict(values)
+        return values
+    def findall(query):
+        value_list=[]
+        values=AccMasterDb.mycol.find(query,{})
+        for v in values:
+
+            v=AttributeDict(v)
+            value_list.append(v)
+        return value_list
+    def create(value):
+         value=AttributeDict(value)
+         localTime = time.time()
+         mydoc = {
+        "_id":localTime,
+        "accMasterId":localTime,
+        "portfolio":value.AName,
+        "account":value.SName,
+        "ThresholdScore":0.85,
+        "isActive":"Y",
+        "isCreated":"Not Started",
+        "CreatedDateTime": datetime.datetime.now(),
+        "LastUpdatedDateTime": datetime.datetime.now(),
+         }
+         PtrnRecogCreatedData = AccMasterDb.mycol.insert_one(mydoc)
+         return PtrnRecogCreatedData.inserted_id
+    
+    def update(id,value:dict):
+      
+        newvalues = { "$set": value }
+        PtrnRecogUpdatedData=AccMasterDb.mycol.update_one({"_id":id},newvalues)
+        log.debug(str(newvalues)) 
+        return PtrnRecogUpdatedData.acknowledged
+    
+    def delete(id):
+        return AccMasterDb.mycol.delete_many({"_id":id}).acknowledged
+        # DocProcDtl.mycol.delete_many({})
+        # Docpagedtl.mycol.delete_many({})
+    
+    

src/privacy/dao/AccPtrnMappingDb.py

@@ -0,0 +1,71 @@
+'''
+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.
+'''
+
+import pymongo
+import datetime,time
+from privacy.dao.DatabaseConnection import DB
+from dotenv import load_dotenv
+from privacy.config.logger import CustomLogger
+
+load_dotenv()
+log = CustomLogger()
+
+class AttributeDict(dict):
+    __getattr__ = dict.__getitem__
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+mydb=DB.connect()
+
+
+class AccPtrnDb:
+    mycol = mydb["AccPtrn"]
+    def findOne(id):
+        values=AccPtrnDb.mycol.find({"_id":id},{})[0]
+        # print(values)
+        values=AttributeDict(values)
+        return values
+    def findall(query):
+        value_list=[]
+        values=AccPtrnDb.mycol.find(query,{})
+        for v in values:
+
+            v=AttributeDict(v)
+            value_list.append(v)
+        return value_list
+    def create(value):
+         value=AttributeDict(value)
+         localTime = time.time()
+         mydoc = {
+        "_id":localTime,
+        "accMasterId":value.Aid,
+        "ptrnRecId":value.Pid,
+        "isActive":"Y",
+        "isCreated":"Not Started",
+        "CreatedDateTime": datetime.datetime.now(),
+        "LastUpdatedDateTime": datetime.datetime.now(),
+         }
+         PtrnRecogCreatedData = AccPtrnDb.mycol.insert_one(mydoc)
+         return PtrnRecogCreatedData.inserted_id
+    
+    def update(id,value:dict):
+      
+        newvalues = { "$set": value }
+        PtrnRecogUpdatedData=AccPtrnDb.mycol.update_one({"_id":id},newvalues)
+        log.debug(str(newvalues)) 
+        return PtrnRecogUpdatedData.acknowledged
+    
+    def delete(id):
+        AccPtrnDb.mycol.delete_many({"_id":id})
+        # DocProcDtl.mycol.delete_many({})
+        # Docpagedtl.mycol.delete_many({})
+    
+    

src/privacy/dao/DataRecogdb.py

@@ -0,0 +1,78 @@
+'''
+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.
+'''
+
+import pymongo
+import datetime,time
+from privacy.dao.DatabaseConnection import DB
+from dotenv import load_dotenv
+from privacy.config.logger import CustomLogger
+
+load_dotenv()
+log = CustomLogger()
+
+class AttributeDict(dict):
+    __getattr__ = dict.__getitem__
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+mydb=DB.connect()
+
+
+
+class RecogDb:
+    mycol = mydb["Recog"]
+    def findOne(id):
+        values=RecogDb.mycol.find({"_id":id},{})[0]
+        # print(values)
+        values=AttributeDict(values)
+        return values
+    def findall(query):
+        value_list=[]
+        values=RecogDb.mycol.find(query,{})
+        for v in values:
+
+            v=AttributeDict(v)
+            value_list.append(v)
+        return value_list
+    def create(value):
+         value=AttributeDict(value)
+         localTime = time.time()
+         mydoc = {
+        "_id":localTime,
+        "RecogId":localTime,
+        "RecogName":value.Name,
+        "supported_entity":value.entity,
+        "RecogType":value.type,
+        "Score":value.score,
+        "Context":value.context,
+        "isEditable":value.edit,
+        "isPreDefined":value.define,
+        "isActive":"Y",
+        "isCreated":"Not Started",
+        "CreatedDateTime": datetime.datetime.now(),
+        "LastUpdatedDateTime": datetime.datetime.now(),
+         }
+         PtrnRecogCreatedData = RecogDb.mycol.insert_one(mydoc)
+         return PtrnRecogCreatedData.inserted_id
+    
+    def update(id,value:dict):
+      
+        newvalues = { "$set": value }
+        PtrnRecogUpdatedData=RecogDb.mycol.update_one({"_id":id},newvalues)
+        log.debug(str(newvalues)) 
+        return PtrnRecogUpdatedData.acknowledged
+    
+    def delete(id):
+        RecogDb.mycol.delete_many({"_id":id})
+        # DocProcDtl.mycol.delete_many({})
+        # Docpagedtl.mycol.delete_many({})
+    
+    

src/privacy/dao/DatabaseConnection.py

@@ -0,0 +1,32 @@
+'''
+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.
+'''
+
+
+import os
+import pymongo
+
+from dotenv import load_dotenv
+from privacy.config.logger import CustomLogger
+import sys
+load_dotenv()
+
+log = CustomLogger()
+
+
+class DB:
+    def connect():
+        try:
+            myclient = pymongo.MongoClient(os.getenv("MONGO_PATH")) 
+            mydb = myclient[os.getenv("DB_NAME")]
+            return mydb
+        except Exception as e:
+            log.info(str(e))
+            sys.exit()
+            

src/privacy/dao/EntityDb.py

@@ -0,0 +1,70 @@
+'''
+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.
+'''
+
+import pymongo
+import datetime,time
+from privacy.dao.DatabaseConnection import DB
+from dotenv import load_dotenv
+from privacy.config.logger import CustomLogger
+
+load_dotenv()
+log = CustomLogger()
+
+class AttributeDict(dict):
+    __getattr__ = dict.__getitem__
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+mydb=DB.connect()
+
+
+class EntityDb:
+    mycol = mydb["Entity"]
+    def findOne(id):
+        values=EntityDb.mycol.find({"_id":id},{})[0]
+        # print(values)
+        values=AttributeDict(values)
+        return values
+    def findall(query):
+        value_list=[]
+        values=EntityDb.mycol.find(query,{})
+        for v in values:
+
+            v=AttributeDict(v)
+            value_list.append(v)
+        return value_list
+    def create(value):
+         value=AttributeDict(value)
+         localTime = time.time()
+         mydoc = {
+        "_id":localTime,
+        "EntityId":localTime,
+        "EntityName":value.Name,
+        "RecogId":value.dgid,
+         }
+         PtrnRecogCreatedData = EntityDb.mycol.insert_one(mydoc)
+         return PtrnRecogCreatedData.acknowledged
+    
+    def update(id,value:dict):
+      
+        newvalues = { "$set": value }
+        PtrnRecogUpdatedData=EntityDb.mycol.update_one({"_id":id},newvalues)
+        log.debug(str(newvalues)) 
+        return PtrnRecogUpdatedData.acknowledged
+    
+    def delete(id):
+        x=EntityDb.mycol.delete_many({"_id":id})
+        return x.acknowledged
+        # DocProcDtl.mycol.delete_many({})
+        # Docpagedtl.mycol.delete_many({})
+    def deleteMany(query):
+        x=EntityDb.mycol.delete_many(query)
+        return x.acknowledged

src/privacy/dao/TelemetryFlagDb.py

@@ -0,0 +1,70 @@
+'''
+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.
+'''
+
+import pymongo
+import datetime,time
+from privacy.dao.DatabaseConnection import DB
+from dotenv import load_dotenv
+from privacy.config.logger import CustomLogger
+
+load_dotenv()
+log = CustomLogger()
+
+class AttributeDict(dict):
+    __getattr__ = dict.__getitem__
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+mydb=DB.connect()
+
+
+
+class TelemetryFlag:
+    mycol = mydb["TelemetryFlag"]
+    def findOne(id):
+        values=TelemetryFlag.mycol.find({"_id":id},{})[0]
+        # print(values)
+        values=AttributeDict(values)
+        return values
+    def findall(query):
+        value_list=[]
+        values=TelemetryFlag.mycol.find(query,{})
+        for v in values:
+
+            v=AttributeDict(v)
+            value_list.append(v)
+        return value_list
+    def create(value):
+         value=AttributeDict(value)
+         localTime = time.time()
+         mydoc = {
+        "_id":localTime,
+        "Module":value.module,
+        "TelemetryFlag":False,
+        "CreatedDateTime": datetime.datetime.now(),
+        "LastUpdatedDateTime": datetime.datetime.now(),
+         }
+         PtrnRecogCreatedData = TelemetryFlag.mycol.insert_one(mydoc)
+         return PtrnRecogCreatedData.inserted_id
+    
+    def update(id,value:dict):
+      
+        newvalues = { "$set": value }
+        PtrnRecogUpdatedData=TelemetryFlag.mycol.update_one({"_id":id},newvalues)
+        log.debug(str(newvalues)) 
+        return PtrnRecogUpdatedData.acknowledged
+    
+    def delete(id):
+        TelemetryFlag.mycol.delete_many({"_id":id})
+        # DocProcDtl.mycol.delete_many({})
+        # Docpagedtl.mycol.delete_many({})
+    
+    

src/privacy/dao/privacy/DatabaseConnection.py

@@ -0,0 +1,27 @@
+'''
+© <2023> Infosys Limited, Bangalore, India. All Rights Reserved.
+ Version: 
+Except for any free or open source software components embedded in this Infosys proprietary software program (“Program”), this Program is protected by copyright laws, international treaties and other pending or existing intellectual property rights in India, the United States and other countries. Except as expressly permitted, any unauthorized reproduction, storage, transmission in any form or by any means (including without limitation electronic, mechanical, printing, photocopying, recording or otherwise), or any distribution of this Program, or any portion of it, may result in severe civil and criminal penalties, and will be prosecuted to the maximum extent possible under the law.
+'''
+
+import os
+import pymongo
+
+from dotenv import load_dotenv
+from privacy.config.logger import CustomLogger
+import sys
+load_dotenv()
+
+log = CustomLogger()
+
+
+class DB:
+    def connect():
+        try:
+            myclient = pymongo.MongoClient(os.getenv("MONGO_PATH")) 
+            mydb = myclient[os.getenv("PRIVACY_DB_NAME")]
+            return mydb
+        except Exception as e:
+            log.info(str(e))
+            sys.exit()
+            

src/privacy/dao/privacy/PrivacyException.py

@@ -0,0 +1,67 @@
+'''
+© <2023> Infosys Limited, Bangalore, India. All Rights Reserved.
+ Version: 
+Except for any free or open source software components embedded in this Infosys proprietary software program (“Program”), this Program is protected by copyright laws, international treaties and other pending or existing intellectual property rights in India, the United States and other countries. Except as expressly permitted, any unauthorized reproduction, storage, transmission in any form or by any means (including without limitation electronic, mechanical, printing, photocopying, recording or otherwise), or any distribution of this Program, or any portion of it, may result in severe civil and criminal penalties, and will be prosecuted to the maximum extent possible under the law.
+'''
+import pymongo
+import datetime,time
+from privacy.dao.privacy.DatabaseConnection import DB
+from dotenv import load_dotenv
+from privacy.config.logger import CustomLogger
+
+load_dotenv()
+log = CustomLogger()
+
+class AttributeDict(dict):
+    __getattr__ = dict.__getitem__
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+mydb=DB.connect()
+
+
+
+class ExceptionDb:
+    mycol = mydb["PrivacyException"]
+    def findOne(id):
+        values=ExceptionDb.mycol.find({"_id":id},{})[0]
+        # print(values)
+        values=AttributeDict(values)
+        return values
+    def findall(query):
+        value_list=[]
+        values=ExceptionDb.mycol.find(query,{})
+        for v in values:
+
+            v=AttributeDict(v)
+            value_list.append(v)
+        return value_list
+    def create(value):
+         value=AttributeDict(value)
+         localTime = time.time()
+         mydoc = {
+        "_id":localTime,
+        "ExceptionId":localTime,
+        "UUID":value.UUID,
+        "function":value.function,
+        "msg":value.msg,
+        "description":value.description,
+        "CreatedDateTime": datetime.datetime.now(),
+         }
+         PtrnRecogCreatedData = ExceptionDb.mycol.insert_one(mydoc)
+         return PtrnRecogCreatedData.inserted_id
+    
+    def update(id,value:dict):
+      
+        newvalues = { "$set": value }
+        PtrnRecogUpdatedData=ExceptionDb.mycol.update_one({"_id":id},newvalues)
+        log.debug(str(newvalues)) 
+        return PtrnRecogUpdatedData.acknowledged
+    
+    def delete(id):
+        ExceptionDb.mycol.delete_many({"_id":id})
+        # DocProcDtl.mycol.delete_many({})
+        # Docpagedtl.mycol.delete_many({})
+    
+    

src/privacy/dao/privacy/TelemetryDb.py

@@ -0,0 +1,70 @@
+'''
+© <2023> Infosys Limited, Bangalore, India. All Rights Reserved.
+ Version: 
+Except for any free or open source software components embedded in this Infosys proprietary software program (“Program”), this Program is protected by copyright laws, international treaties and other pending or existing intellectual property rights in India, the United States and other countries. Except as expressly permitted, any unauthorized reproduction, storage, transmission in any form or by any means (including without limitation electronic, mechanical, printing, photocopying, recording or otherwise), or any distribution of this Program, or any portion of it, may result in severe civil and criminal penalties, and will be prosecuted to the maximum extent possible under the law.
+'''
+import pymongo
+import datetime,time
+from privacy.dao.privacy.DatabaseConnection import DB
+from dotenv import load_dotenv
+from privacy.config.logger import CustomLogger
+
+load_dotenv()
+log = CustomLogger()
+
+class AttributeDict(dict):
+    __getattr__ = dict.__getitem__
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+mydb=DB.connect()
+
+
+
+class TelemetryDb:
+    mycol = mydb["PrivacyTelemetry"]
+    def findOne(id):
+        values=TelemetryDb.mycol.find({"_id":id},{})[0]
+        # print(values)
+        values=AttributeDict(values)
+        return values
+    def findall(query):
+        value_list=[]
+        values=TelemetryDb.mycol.find(query,{})
+        for v in values:
+            v=AttributeDict(v)
+            value_list.append(v)
+        return value_list
+    def create(value):
+         log.debug("Create telemetry data")
+         value=AttributeDict(value)
+         localTime = time.time()
+         mydoc = {
+        "_id":localTime,
+        "uniqueid":value.uniqueid,
+        "tenant":value.tenant,
+        "apiname":value.apiname,
+        "user":value.user,
+        "lotNumber": value.lotNumber,
+        # "exclusionList":value.exclusionList,
+        "date": value.date,
+        "request":value.request,
+        "response":value.response,
+         }
+         PtrnRecogCreatedData = TelemetryDb.mycol.insert_one(mydoc)
+         return PtrnRecogCreatedData.inserted_id
+    
+    def update(id,value:dict):
+      
+        newvalues = { "$set": value }
+        PtrnRecogUpdatedData=TelemetryDb.mycol.update_one({"_id":id},newvalues)
+        log.debug(str(newvalues)) 
+        return PtrnRecogUpdatedData.acknowledged
+    
+    def delete(id):
+        TelemetryDb.mycol.delete_many({"_id":id})
+        # DocProcDtl.mycol.delete_many({})
+        # Docpagedtl.mycol.delete_many({})
+    
+    

src/privacy/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/privacy/exception/exception.py

@@ -0,0 +1,50 @@
+'''
+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.
+'''
+
+"""
+fileName: exception.py
+description: handles usecase module specific exception
+"""
+
+import sys, traceback
+
+from privacy.constants.local_constants  import SPACE_DELIMITER,PLACEHOLDER_TEXT,USECASE_ALREADY_EXISTS,USECASE_NOT_FOUND_ERROR,USECASE_NAME_VALIDATION_ERROR
+
+from aicloudlibs.constants import constants as global_constants
+from abc import ABC
+
+
+class PrivacyException(Exception, ABC):
+    """
+    dscription: Abstract base class of UsecaseException.
+    """
+
+    def __init__(self, detail: str) -> None:
+        self.status_code = global_constants.HTTP_STATUS_BAD_REQUEST
+        super().__init__(detail)
+
+
+class PrivacyNotFoundError(PrivacyException):
+    """
+    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 PrivacyNameNotEmptyError(PrivacyException):
+    """
+    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/privacy/mappers/mappers.py

@@ -0,0 +1,177 @@
+'''
+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.
+'''
+
+"""
+fileName: mappers.py
+description: A Pydantic model object for usecase entity model
+             which maps the data model to the usecase entity schema
+"""
+
+from pydantic import BaseModel, Field
+from datetime import datetime
+from typing import Optional,Union, List
+
+"""
+description: piiEntity
+params:
+"""
+
+
+class PIIEntity(BaseModel):
+    type: Optional[str] = Field(example="US_SSN")
+    beginOffset: Optional[int] = Field(example=19)
+    endOffset: Optional[int] = Field(example=28)
+    score:Optional[float]=Field(example=1.1)  
+    responseText:Optional[str]=Field(example="012884567")
+
+    class Config:
+        orm_mode = True
+
+class PIIItems(BaseModel):
+    start: Optional[int] = Field(example=19)
+    end: Optional[int] = Field(example=28)
+    entity_type: Optional[str] = Field(example="US_SSN") 
+    text:Optional[str]=Field(example="John Smith's SSN is 012884567")
+    operator:Optional[str]= Field(example="encrypt") 
+
+    class Config:
+        orm_mode = True
+
+class PIIImageEntity(BaseModel):
+    type: str = Field(example="US_SSN")
+
+    class Config:
+        orm_mode = True
+
+class PIIAnalyzeRequest(BaseModel):
+    inputText: str = Field(example="John Smith's SSN is 012884567")
+    # entity_type: Optional[str] = Field(example="COMPANY_NAME")
+    portfolio:Optional[str] = Field(example="string")
+    account:Optional[str] = Field(example="string")
+    exclusionList:Optional[str] = Field(example="Karan,Infosys")
+    user: Optional[str] = Field(None)
+    lotNumber:Optional[str] = Field(None)
+    
+class PIIEncryptResponse(BaseModel):
+    text: str = Field(example="John Smith's SSN is 012884567")
+    items: List[PIIItems]
+
+    class Config:
+        orm_mode = True
+
+class PIIDecryptRequest(BaseModel):
+    text: str = Field(example="John Smith's SSN is 012884567")
+    items: List[PIIItems]
+
+class PIIAnalyzeResponse(BaseModel):
+    PIIEntities: List[PIIEntity]
+
+    class Config:
+        orm_mode = True
+
+
+class PIIAnonymizeRequest(BaseModel):
+    inputText: str = Field(example="John Smith's SSN is 012884567")
+    portfolio:Optional[str] = Field(example="string")
+    account:Optional[str] = Field(example="string")
+    exclusionList:Optional[str] = Field(example="Karan,Infosys")
+    piiEntitiesToBeRedacted: Optional[list] = Field(example=["US_SSN"])
+    redactionType: Optional[str] = Field(example='replace')
+    user: Optional[str] = Field(example = None)
+    lotNumber:Optional[str] = Field(example = None)
+    fakeData: Optional[bool] = Field(example = False)
+
+
+
+class PIIAnonymizeResponse(BaseModel):
+    anonymizedText: str = Field(example="John Smith's SSN is <US_SSN>")
+
+    class Config:
+        orm_mode = True
+        
+class PIIDecryptResponse(BaseModel):
+    decryptedText: str = Field(example="John Smith's SSN is <US_SSN>")
+
+    class Config:
+        orm_mode = True   
+    
+#class Image
+class PIIImageAnalyzeRequest(BaseModel):
+    class Config:
+        orm_mode = True
+
+class PIIImageAnonymizeResponse(BaseModel):
+    base64text: str=Field(example="kshdbfbfwbedhbaskjbakbsakjnalhbsfsfvslkjdnlkjdsnkdsbflkjsbdsklakbkdb")
+
+    class Config:
+        orm_mode = True
+
+class PIIImageEntity(BaseModel):
+    type: str = Field(example="US_SSN")
+
+    class Config:
+        orm_mode = True
+
+class PIIImageAnalyzeResponse(BaseModel):
+    PIIEntities: List[PIIImageEntity]
+
+    class Config:
+        orm_mode = True
+
+class PIIMultipleImageAnalyzeResponse(BaseModel):
+    PIIEntities: List[List[PIIImageEntity]]
+
+    class Config:
+        orm_mode = True
+
+
+
+class PIIPrivacyShieldRequest(BaseModel):
+    inputText: str = Field(example="John Smith's SSN is 012884567")
+    # entity_type: Optional[str] = Field(example="COMPANY_NAME")
+    portfolio:Optional[str] = Field(example="string")
+    account:Optional[str] = Field(example="string")
+
+    
+
+
+
+class PrivacyShield(BaseModel):
+    entitiesRecognised:list = Field(example=["US_SSN"])
+    entitiesConfigured :list = Field(example=["US_SSN"])
+    result:str =""
+
+class PIIPrivacyShieldResponse(BaseModel):
+    privacyCheck: List[PrivacyShield]
+
+    class Config:
+        orm_mode = True
+
+
+
+class LogoHidingResponse(BaseModel):
+    base64text: str=Field(example="kshdbfbfwbedhbaskjbakbsakjnalhbsfsfvslkjdnlkjdsnkdsbflkjsbdsklakbkdb")
+
+    class Config:
+        orm_mode = True
+
+class Telemetry(BaseModel):
+    Module:str= Field(example = "Privacy")
+    TelemetryFlagValue : bool = Field(example=True) 
+  
+
+class TelemetryResponse(BaseModel):
+    result : List[Telemetry]
+
+    class Config:
+        orm_mode = True
+    
+class PIICodeDetectRequest(BaseModel):
+    inputText: str = Field(example="John Smith's SSN is 012884567")

src/privacy/routing/privacy_router.py

@@ -0,0 +1,1747 @@
+'''
+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.
+'''
+
+from io import BytesIO
+from tempfile import NamedTemporaryFile
+import threading
+import time
+import uuid
+
+import requests
+from privacy.util.code_detect.ner.pii_inference.netcustom import code_detect_ner
+from privacy.util.code_detect.ner.CodePIINER import codeNer
+# from privacy.dao.TelemetryFlagDb import TelemetryFlag
+from fastapi import Depends, Query,Request,APIRouter, HTTPException, WebSocket,websockets,FastAPI,Cookie,Body
+from typing import List, Union
+
+from privacy.service.privacytelemetryservice import PrivacyTelemetryRequest
+from privacy.service.Video_service import *
+
+from fastapi.params import Form
+from privacy.mappers.mappers import *
+#from privacy.mappers.mappers import PIIEntity, PIIAnalyzeRequest, PIIAnonymizeResponse, PIIAnonymizeRequest,PIIAnalyzeResponse,PIIImageAnonymizeResponse,PIIImageAnalyzeResponse,PIIImageAnalyzeRequest
+
+
+from privacy.service.Video_service import VideoService
+# from privacy.service.logo_service import Logo 
+from privacy.service.code_detect_service import *
+from privacy.service.excel_service import Excel
+
+from privacy.exception.exception import PrivacyException
+from privacy.config.logger import CustomLogger
+
+from fastapi import FastAPI, UploadFile,File
+from fastapi.responses import FileResponse
+from datetime import date
+import concurrent.futures
+from fastapi import Request
+from fastapi.responses import StreamingResponse
+from privacy.util.code_detect.ner.pii_inference.netcustom import *
+# from privacy.util.face_detect.mask_detect_video import mask_video
+import logging
+# from privacy.code_generator.codegeneration import create_new_recognizer_file,modify_recognizer_registry,modify_init_py,run_wheel_creation_commands, copy_wheel_file,test
+# from privacy.dao.privacy.PrivacyException import ExceptionDb
+# from privacy.dao.privacy.TelemetryDb import TelemetryDb
+from privacy.service.api_req import *
+from privacy.service.__init__ import *
+from privacy.service.textPrivacy import TextPrivacy,Shield
+from privacy.service.imagePrivacy import ImagePrivacy
+from privacy.service.dicomPrivacy import DICOMPrivacy
+import cv2
+import numpy as np
+router = APIRouter()
+# user_id=1234
+log=CustomLogger()
+app = FastAPI()
+
+fileRouter=APIRouter()
+# logger = UserLogger()
+
+import tracemalloc
+from transformers import AutoModelForTokenClassification, AutoTokenizer
+#@router.post('/privacy/text/analyze', response_model= PIIAnalyzeResponse)
+today = date.today()
+from datetime import datetime
+import asyncio
+from dotenv import load_dotenv
+load_dotenv()
+# import gc
+import os
+from uuid import UUID, uuid4
+# from fastapi_sessions.backends.implementations import InMemoryBackend
+# from fastapi_sessions.frontends.implementations import SessionCookie, CookieParameters
+# from request_id_store import request_ids
+from privacy.config.logger import request_id_var
+import traceback
+from fastapi import APIRouter, HTTPException, Request, Depends
+from pydantic import BaseModel
+from fastapi.responses import JSONResponse
+from privacy.util.auth.auth_client_id import get_auth_client_id
+from privacy.util.auth.auth_jwt import get_auth_jwt
+from privacy.util.auth.auth_none import get_auth_none
+
+# from fastapi.se
+
+# from fastapi_session import get_session
+# returns current date and time
+now = datetime.now()
+# from memory_profiler import profile
+# telFlagData = TelemetryFlag.findall({})[0]
+# tel_Falg = telFlagData["TelemetryFlag"]
+# telFlagData = TelemetryFlag.findall({"Module":"Privacy"})
+# print("Teldata==",telFlagData)
+# if(len(telFlagData) == 0):
+    # telData = TelemetryFlag.create({"module":"Privacy"})
+    # print("telData===",telData)
+magMap = {"True": True, "False": False,"true": True, "false": False}
+tel_Falg=os.getenv("TELE_FLAG")
+tel_Falg=magMap[tel_Falg]
+# tel_Falg = os.getenv("TELE_FLAG", "False")  # Default to "False" if TELE_FLAG is not set
+# tel_Falg = magMap.get(tel_Falg, False)  # Use .get() to safely access the dictionary and default to False if the key doesn't exist
+# print("===============",tel_Falg,type(tel_Falg))
+privacytelemetryurl = os.getenv("PRIVACY_TELEMETRY_URL")
+privacyerrorteleurl = os.getenv("PRIVACY_ERROR_URL")
+
+# print("tel_falg===",tel_Falg)
+# Load the model and tokenizer for CODEFILE API
+local_model_directory = "privacy/util/code_detect/ner/pii_inference/nermodel"
+model = AutoModelForTokenClassification.from_pretrained(local_model_directory)
+tokenizer = AutoTokenizer.from_pretrained(local_model_directory, model_max_length=10000)
+
+
+
+class NoAccountException(Exception):
+    pass
+
+class NoAdminConnException(Exception):
+    pass
+
+
+
+## FUNCTION FOR FAIL_SAFE TELEMETRY
+def send_telemetry_request(privacy_telemetry_request):
+    id = uuid.uuid4().hex
+    request_id_var.set("telemetry")
+
+    try:
+        # print("==",privacy_telemetry_request)
+        log.debug("teleReq="+str(privacy_telemetry_request))
+        
+        response = requests.post(privacytelemetryurl, json=privacy_telemetry_request)
+        # print/("===,",response)
+        response.raise_for_status()
+        response_data = response.json()
+        log.debug("tele data response: "+ str(response))
+        # print(response_data)
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"send_telemetry_requestFunction","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        raise HTTPException(
+            status_code=500,    
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+        
+        
+class Telemetry:
+    def error_telemetry_request(errobj,id):
+        request_id_var.set(id)
+
+        try:
+            # print("==",privacy_telemetry_request)
+            log.debug("teleReq="+str(errobj))
+            if(tel_Falg):
+
+                response = requests.post(privacyerrorteleurl, json=errobj)
+                # print("===,",response)
+                response.raise_for_status()
+                response_data = response.json()
+                log.debug("tele error response: "+ str(response))
+                # print(response_data)
+        except Exception as e:
+            log.error(str(e))
+            # ExceptionDb.create({"UUID":request_id_var.get(),"function":"send_telemetry_requestFunction","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+            raise HTTPException(
+                status_code=500,    
+                detail="Please check with administration!!",
+                headers={"X-Error": "Please check with administration!!"})
+        
+
+
+# Authentication 
+
+auth_type = os.environ.get("AUTH_TYPE")
+
+if auth_type == "azure":
+    auth = get_auth_client_id()
+elif auth_type == "jwt":
+    auth = get_auth_jwt()
+
+elif auth_type == 'none':
+    auth = get_auth_none()
+else:
+    raise HTTPException(status_code=500, detail="Invalid authentication type configured")
+    
+
+router = APIRouter()
+
+
+@router.post('/privacy/text/analyze', response_model= PIIAnalyzeResponse)
+# @profile
+def analyze(payload: PIIAnalyzeRequest,auth= Depends(auth)):
+
+    # gc.collect()
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered into analyze routing method" )
+
+    try:
+        log.debug("request payload: "+ str(payload))
+        startTime = time.time()
+        log.debug("Entered into analyze function")
+        tracemalloc.start()
+        # raise Exception()
+        response = TextPrivacy.analyze(payload)
+        ApiCall.delAdminList()
+        tracemalloc.stop()
+        log.debug("Returned from analyze function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+          
+        log.info("Total Time taken "+str(totalTime))
+        if(response==None):
+            # print("Inside Raise Exception")
+            # return "Portfolio/Account Is Incorrect"
+            raise NoAccountException
+        # print("---",response.admin)
+        if(response==404):
+            raise NoAdminConnException
+        #     raise HTTPException(
+        #     status_code=430,
+        #     detail="Portfolio/Account Is Incorrect",
+        #     headers={"X-Error": "There goes my error"},
+
+        # )
+    
+        log.debug("response : "+ str(response))
+        log.info("exit create from analyze routing method")
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        log.debug("TelFlag==="+ str(tel_Falg))
+        # TelemetryDb.create({"UUID":id,"tenant":"privacy","apiName":analyze.__name__,"portfolio":payload.portfolio,"accountName":payload.account,"exclusion_list":payload.exclusionList,"entityrecognised":"Text"})
+        if(tel_Falg == True):
+            responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
+            requestList = payload.__dict__
+            requestObj = {
+                "portfolio_name": payload.portfolio if payload.portfolio is not None else "None",
+                "account_name": payload.account if payload.account is not None else "None",
+                "inputText": requestList["inputText"],
+                "exclusion_list": requestList["exclusionList"].split(',') if requestList["exclusionList"] is not None else [],
+            }
+            # lotNumber = 0  # Initialize lotNumber with a default value
+            # if payload.lotNumber is not None:
+            #     lotNumber = payload.lotNumber
+            
+            telemetryPayload = {
+                "uniqueid": id,
+                "tenant": "privacy",
+                "apiname": analyze.__name__,           
+                "user": payload.user if payload.user is not None else "None",
+                "date":now.isoformat(),
+                "lotNumber": payload.lotNumber if payload.lotNumber is not None else "None",
+                # "exclusionList": payload.exclusionList,
+                "request": requestObj,
+                "response": responseList
+            }
+            # TelemetryDb.create(telemetryPayload)
+            
+            # Trigger the API call asynchronously using a separate thread
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                executor.submit(send_telemetry_request, telemetryPayload)
+            log.info("******TELEMETRY REQUEST COMPLETED********")
+        # responseprivacytelemetry = requests.post(privacytelemetryurl, json=privacy_telemetry_request.__dict__)
+        # gc.collect()
+        return response
+    except PrivacyException as cie:
+        log.debug("Exception for analyze")
+        log.error(cie.__dict__)
+
+        er=[{"UUID":request_id_var.get(),"function":"textAnalyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        # 
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        # ExceptionDb.create({"UUID":id,"function":"textAnalyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
+        # print(cie)
+        # print(cie.__dict__)
+        log.error(cie, exc_info=True)
+        log.info("exit create from analyze routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except NoAdminConnException:
+        raise HTTPException(
+            status_code=435,
+            detail=" Accounts and Portfolio not available with the Subscription!!",
+            headers={"X-Error": "Admin Connection is not established,"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # print(error_dict)
+        er=[{"UUID":request_id_var.get(),"function":"textAnalyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        # 
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"textAnalyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+    
+@router.post('/privacy/text/anonymize', response_model= PIIAnonymizeResponse)
+def anonymize(payload: PIIAnonymizeRequest,auth= Depends(auth)):
+    
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    
+    log.info("Entered create into anonymize routing method")
+    try:
+        # log.info("Entered create usecase routing method" )
+        log.debug("request payload: "+ str(payload))
+        startTime = time.time()
+        log.debug("Entered into anonymize function")
+        response = TextPrivacy.anonymize(payload)
+        ApiCall.delAdminList()
+        log.debug("Returned from anonymize function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        if(response==None):
+            raise NoAccountException
+        if(response==404):
+            raise NoAdminConnException
+        #     raise HTTPException(
+        #     status_code=430,
+        #     detail="Portfolio/Account Is Incorrect",
+        #     headers={"X-Error": "There goes my error"},
+        # )
+        # log.info("after invoking create usecase service ")
+        log.debug("response : "+ str(response))
+        log.info("exit create from anonymize routing method")
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        # log.debug("Tel Flag==="+ str(tel_Falg))
+        if(tel_Falg == True):
+            log.debug("Inside Telemetry Flag")
+            requestList = payload.__dict__
+            requestObj = {
+               "portfolio_name": payload.portfolio if payload.portfolio is not None else "None",
+                "account_name": payload.account if payload.account is not None else "None",
+                "inputText": requestList["inputText"],
+                "exclusion_list": requestList["exclusionList"].split(',') if requestList["exclusionList"] is not None else [],
+            }
+            responseObj = {
+                "type": "None",
+                "beginOffset": 0,
+                "endOffset": 0,
+                "score": 0,
+                "responseText": response.anonymizedText
+            }
+            # lotNumber = 0  # Initialize lotNumber with a default value
+            # if payload.lotNumber is not None:
+            #     lotNumber = payload.lotNumber
+            telemetryPayload = {
+                "uniqueid": id,
+                "tenant": "privacy",
+                "apiname": anonymize.__name__,
+                "user": payload.user if payload.user is not None else "None",
+                "date":now.isoformat(),
+                "lotNumber": payload.lotNumber if payload.lotNumber is not None else "None",
+                # "exclusionList": payload.exclusionList,
+                "request": requestObj,
+                "response": [responseObj]
+            }
+            # TelemetryDb.create(telemetryPayload)
+            
+            
+            # Trigger the API call asynchronously using a separate thread
+           
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                executor.submit(send_telemetry_request, telemetryPayload)
+            log.info("******TELEMETRY REQUEST COMPLETED********")
+        return response
+    except PrivacyException as cie:
+        log.error("Exception for anonymize")
+        log.error(cie.__dict__)
+        er=[{"UUID":id,"function":"textAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        # 
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        log.error(cie, exc_info=True)
+        log.info("exit create from anonymize routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except NoAdminConnException:
+        raise HTTPException(
+            status_code=435,
+            detail=" Accounts and Portfolio not available with the Subscription!!",
+            headers={"X-Error": "Admin Connection is not established,"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"textAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        er=[{"UUID":request_id_var.get(),"function":"textAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        # 
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+            
+@router.post('/privacy/text/encrpyt',response_model=PIIEncryptResponse)
+def encrypt(payload: PIIAnonymizeRequest,auth= Depends(auth)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    
+    log.info("Entered create into encrypt routing method")
+    try:
+        log.debug("request payload: "+ str(payload))
+        startTime = time.time()
+        log.debug("Entered into encrypt function")
+        response = TextPrivacy.encrypt(payload)
+        log.debug("Returned from encrypt function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        print("response=======",response)
+        log.info("Total Time taken "+str(totalTime))
+        
+        if(response==None):
+            raise NoAccountException
+        
+        # log.debug("response : "+ str(response))
+        log.info("exit create from encrypt routing method")
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        # log.debug("Tel Flag==="+ str(tel_Falg))
+        if(tel_Falg == True):
+            log.debug("Inside Telemetry Flag")
+            requestList = payload.__dict__
+            requestObj = {
+               "portfolio_name": payload.portfolio if payload.portfolio is not None else "None",
+                "account_name": payload.account if payload.account is not None else "None",
+                "inputText": requestList["inputText"],
+                "exclusion_list": requestList["exclusionList"].split(',') if requestList["exclusionList"] is not None else [],
+            }
+            responseObj = {
+                "type": "None",
+                "beginOffset": 0,
+                "endOffset": 0,
+                "score": 0,
+                "responseText": response.text
+            }
+            # lotNumber = 0  # Initialize lotNumber with a default value
+            # if payload.lotNumber is not None:
+            #      lotNumber = payload.lotNumber
+            telemetryPayload = {
+                "uniqueid": id,
+                "tenant": "privacy",
+                "apiname": anonymize.__name__,
+                "user": payload.user if payload.user is not None else "None",
+                "date":now.isoformat(),
+                "lotNumber": payload.lotNumber if payload.lotNumber is not None else "None",
+                # "exclusionList": payload.exclusionList,
+                "request": requestObj,
+                "response": [responseObj]
+            }
+            # TelemetryDb.create(telemetryPayload)
+            
+            
+            # Trigger the API call asynchronously using a separate thread
+           
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                executor.submit(send_telemetry_request, telemetryPayload)
+            log.info("******TELEMETRY REQUEST COMPLETED********")
+        return response
+       
+    except PrivacyException as cie:
+        log.error("Exception for encrypt")
+        log.error(cie.__dict__)
+        er=[{"UUID":id,"function":"textEncryptRouter","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        # 
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        log.error(cie, exc_info=True)
+        log.info("exit create from encrypt routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"textAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        er=[{"UUID":request_id_var.get(),"function":"textAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+        
+@router.post('/privacy/text/decrpyt',response_model= PIIDecryptResponse)  
+def decrypt(payload: PIIDecryptRequest,auth= Depends(auth)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into decrypt routing method")
+    try:
+        log.debug("request payload: "+ str(payload))
+        startTime = time.time()
+        log.debug("Entered into decrypt function")
+        response = TextPrivacy.decryption(payload)
+        log.debug("Returned from decrypt function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        return response
+    except PrivacyException as cie:
+        log.error("Exception for decrypt")
+        log.error(cie.__dict__)
+        er=[{"UUID":id,"function":"textDecryptRouter","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        # 
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        log.error(cie, exc_info=True)
+        log.info("exit create from decrypt routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"textAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        er=[{"UUID":request_id_var.get(),"function":"textAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id]
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+
+@router.post('/privacy/image/analyze', response_model= PIIImageAnalyzeResponse)
+def image_analyze(ocr: str = Query('Tesseract', enum=['Tesseract',"EasyOcr","ComputerVision"]),magnification:str=Form(...),rotationFlag:str=Form(...),image: UploadFile = File(...),portfolio:Optional[str]=Form(None),account:Optional[str]=Form(None),exclusionList:Optional[str]=Form(None),auth= Depends(auth)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into image_analyze routing method")
+    try:
+       
+        payload={"easyocr":ocr,"mag_ratio":magMap[magnification],"rotationFlag":magMap[rotationFlag],"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
+        log.debug("Requested payload" + str(payload))
+        startTime = time.time()
+        log.debug("Entered into image_analyze function")
+        response = ImagePrivacy.image_analyze(payload)
+        ApiCall.delAdminList()
+        log.debug("Returned from image_analyze function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        if(response==None):
+            raise NoAccountException
+        if(response==404):
+            raise NoAdminConnException        
+        #     raise HTTPException(
+        #     status_code=430,
+        #     detail="Portfolio/Account Is Incorrect",
+        #     headers={"X-Error": "There goes my error"},
+        # )
+        
+        log.info("exit create from image_analyze routing method")
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        log.debug("tel_Flag==="+str(tel_Falg))
+        # responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
+        # requestList = payload.__dict__
+        if(tel_Falg == True):
+            log.debug("Inside Telemetry Flag")
+            # telemetryPayload = {
+            #     "uniqueid": id,
+            #     "tenant": "privacy",
+            #     "apiName": image_analyze.__name__,
+            #     # "portfolio": portfolio,
+            #     # "accountName": account,
+            #     # "exclusion_list": exclusionList,
+            #     "request": requestList,
+            #     "response": responseList
+            # }
+            # TelemetryDb.create(telemetryPayload)
+            
+            # Trigger the API call asynchronously using a separate thread
+            # with concurrent.futures.ThreadPoolExecutor() as executor:
+            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
+            log.info("******TELEMETRY REQUEST COMPLETED********")
+        return response
+        
+    except PrivacyException as cie:
+        log.error("Exception for image_analyze")
+        log.error(cie.__dict__)
+        # ExceptionDb.create({"UUID":id,"function":"imageAnalyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
+        er=[{"UUID":request_id_var.get(),"function":"imageAnalyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        log.error(cie, exc_info=True)
+        log.info("exit create from image_analyze routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except NoAdminConnException:
+        raise HTTPException(
+            status_code=435,
+            detail=" Accounts and Portfolio not available with the Subscription!!",
+            headers={"X-Error": "Admin Connection is not established,"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"imageAnalyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        er=[{"UUID":request_id_var.get(),"function":"imageAnalyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+
+@router.post('/privacy/image/anonymize')
+def image_anonymize(ocr: str = Query('Tesseract', enum=['Tesseract',"EasyOcr","ComputerVision"]),magnification:str=Form(...),rotationFlag:str=Form(...),image: UploadFile = File(...),portfolio:Optional[str]=Form(None),account:Optional[str]=Form(None),exclusionList:Optional[str]=Form(None),auth= Depends(auth)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into image_anonymize routing method" )
+    try:
+        
+        payload={"easyocr":ocr,"mag_ratio":magMap[magnification],"rotationFlag":magMap[rotationFlag],"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
+        log.debug("Payload:"+str(payload))
+        startTime = time.time()
+        log.debug("Entered into image_anonymize function")
+        response = ImagePrivacy.image_anonymize(payload)
+        ApiCall.delAdminList()
+        log.debug("Returned from image_anonymize function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        if(response==None):
+            raise NoAccountException
+        if(response==404):
+            raise NoAdminConnException
+        #     raise HTTPException(
+        #     status_code=430,
+        #     detail="Portfolio/Account Is Incorrect",
+        #     headers={"X-Error": "There goes my error"},
+        # )
+        
+        
+        log.info("exit create from image_anonymize routing method")
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        log.debug("tel_Flag==="+str(tel_Falg))
+        # responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
+        # requestList = payload.__dict__
+        if(tel_Falg == True):
+            log.debug("Inside Telemetry Flag")
+            # telemetryPayload = {
+            #     "uniqueid": id,
+            #     "tenant": "privacy",
+            #     "apiName": image_anonymize.__name__,
+            #     # "portfolio": portfolio,
+            #     # "accountName": account,
+            #     # "exclusion_list": exclusionList,
+            #     "request": requestList,
+            #     "response": responseList
+            # }
+            # TelemetryDb.create(telemetryPayload)
+            
+            # Trigger the API call asynchronously using a separate thread
+            # with concurrent.futures.ThreadPoolExecutor() as executor:
+            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
+            log.info("******TELEMETRY REQUEST COMPLETED********")
+        return response
+        
+    except PrivacyException as cie:
+        log.error("Exception for image_anonymize")
+        log.error(cie.__dict__)
+        # ExceptionDb.create({"UUID":id,"function":"imageAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
+        er=[{"UUID":request_id_var.get(),"function":"imageAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        log.error(cie, exc_info=True)
+        log.info("exit create usecase routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except NoAdminConnException:
+        raise HTTPException(
+            status_code=435,
+            detail=" Accounts and Portfolio not available with the Subscription!!",
+            headers={"X-Error": "Admin Connection is not established,"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"imageAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        er=[{"UUID":request_id_var.get(),"function":"imageAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+
+@router.post('/privacy/image/masking')
+async def image_mask(media: UploadFile = File(...), template: UploadFile = File(...),auth= Depends(auth)):
+    try:
+        # log.info("before invoking create usecase service ")
+        main_image_content = await media.read()
+        nparr = np.fromstring(main_image_content, np.uint8)
+        main_image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+
+        template_image_content = await template.read()
+        nparr = np.fromstring(template_image_content, np.uint8)
+        template_image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        if template_image.shape[0] > main_image.shape[0] or template_image.shape[1] > main_image.shape[1]:
+            raise HTTPException(status_code=400, detail ="Mask image must be smaller or equal in size to the main image")
+        response = await ImagePrivacy.image_masking(main_image,template_image)
+        # log.info("after invoking image masking service")
+        is_success, buffer = cv2.imencode(".png", response)
+
+        # Create a StreamingResponse from the image buffer
+        return StreamingResponse(io.BytesIO(buffer.tobytes()), media_type="image/png")
+    except PrivacyException as cie:
+        log.error(cie.__dict__)
+        log.info("exit create usecase routing method")
+        raise HTTPException(**cie.__dict__)
+# @router.post('/privacy/pii/image/anonymize/zip')                                   #########@#@@#@#$@
+# def image_anonymize(payload: UploadFile):
+#     try:
+#         log.info("Entered create usecase routing method" )
+#         response = service.zipimage_anonymize(payload)
+#         if(response==None):
+#             raise HTTPException(
+#             status_code=430,
+#             detail="Portfolio/Account Is Incorrect",
+#             headers={"X-Error": "There goes my error"},
+#         )
+#         log.info("after invoking create usecase service ")
+        
+#         log.info("exit create usecase routing method")
+#         return response
+        
+#     except PrivacyException as cie:
+#         log.error(cie.__dict__)
+#         log.info("exit create usecase routing method")
+#         raise HTTPException(**cie.__dict__)
+
+
+# @router.post('/privacy/pii/image/anonymize/multiple')
+# def image_anonymize(payload: List[UploadFile] = File(...)):
+#     try:
+#         log.info("Entered create usecase routing method" )
+#         response=[]
+#         for image in payload:
+#             response.append(service.image_anonymize(image))
+            
+#         log.info("after invoking create usecase service ")
+        
+#         log.info("exit create usecase routing method")
+#         return response
+        
+#     except PrivacyException as cie:
+#         log.error(cie.__dict__)
+#         log.info("exit create usecase routing method")
+#         raise HTTPException(**cie.__dict__)
+
+# @router.post('/privacy/pii/image/analyze/multiple')#,response_model=PIIMultipleImageAnalyzeResponse)
+# def image_analyze(payload: List[UploadFile] = File(...)):
+#     try:
+#         log.info("Entered create usecase routing method" )
+#         response=[]
+#         for image in payload:
+#             response.append(service.temp(image))
+        
+#         log.info("after invoking create usecase service ")
+        
+#         log.info("exit create usecase routing method")
+#         return response
+        
+#     except PrivacyException as cie:
+#         log.error(cie.__dict__)
+#         log.info("exit create usecase routing method")
+#         raise HTTPException(**cie.__dict__)
+
+
+@router.post('/privacy/image/verify')
+def image_verify(image: UploadFile = File(...),portfolio:Optional[str]=Form(None),account:Optional[str]=Form(None),exclusionList:Optional[str]=Form(None),auth= Depends(auth)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into image_verify routing method" )
+    try:
+        payload={"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
+        log.debug("request payload: "+str(payload))
+        startTime = time.time()
+        log.debug("Entered into image_verify function")
+        response = ImagePrivacy.image_verify(payload)
+        ApiCall.delAdminList()
+        log.debug("Returned from image_verify function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        if(response==None):
+            raise NoAccountException
+        if(response==404):
+            raise NoAdminConnException        
+        #     raise HTTPException(
+        #     status_code=430,
+        #     detail="Portfolio/Account Is Incorrect",
+        #     headers={"X-Error": "There goes my error"},
+        # )
+      
+        
+        log.info("exit create from image_verify routing method")
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        log.debug("tel_Flag==="+ str(tel_Falg))
+        # responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
+        if(tel_Falg == True):
+            log.debug("Inside Telemetry Flag")
+            # telemetryPayload = {
+            #     "uniqueid": id,
+            #     "tenant": "privacy",
+            #     "apiName": image_verify.__name__,
+            #     # "portfolio": portfolio,
+            #     # "accountName": account,
+            #     # "exclusion_list": exclusionList,
+            #     "request": payload,
+            #     "response": response
+            # }
+            # TelemetryDb.create(telemetryPayload)
+            
+            # Trigger the API call asynchronously using a separate thread
+            # with concurrent.futures.ThreadPoolExecutor() as executor:
+            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
+            log.info("******TELEMETRY REQUEST COMPLETED********")
+        return response
+        
+    except PrivacyException as cie:
+        log.error("Exception for image_verify")
+        log.error(cie.__dict__)
+        # ExceptionDb.create({"UUID":id,"function":"imageVerifyRouter","msg":cie.__dict__,"description":cie.__dict__})
+        er=[{"UUID":request_id_var.get(),"function":"imageVerifyRouter","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        log.error(cie, exc_info=True)
+        log.info("exit create from image_verify routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except NoAdminConnException:
+        raise HTTPException(
+            status_code=435,
+            detail=" Accounts and Portfolio not available with the Subscription!!",
+            headers={"X-Error": "Admin Connection is not established,"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"imageVerifyRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        er=[{"UUID":request_id_var.get(),"function":"imageVerifyRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+    
+    
+@router.post('/privacy/image/hashify')
+def image_hashify(ocr: str = Query('Tesseract', enum=['Tesseract',"EasyOcr","ComputerVision"]),magnification:str=Form(...),rotationFlag:str=Form(...),image: UploadFile = File(...),portfolio:Optional[str]=Form(None),account:Optional[str]=Form(None),exclusionList:Optional[str]=Form(None),auth= Depends(auth)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into imageEncryption routing method" )
+    try:
+        payload={"easyocr":ocr,"mag_ratio":magMap[magnification],"rotationFlag":magMap[rotationFlag],"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
+        log.debug("request payload: "+str(payload))
+        startTime = time.time()
+        log.debug("Entered into imageEncryption function")
+        response = ImagePrivacy.imageEncryption(payload)
+        ApiCall.delAdminList()
+        log.debug("Returned from imageEncryption function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        if(response==None):
+            raise NoAccountException
+        if(response==404):
+            raise NoAdminConnException        
+        #     raise HTTPException(
+        #     status_code=430,
+        #     detail="Portfolio/Account Is Incorrect",
+        #     headers={"X-Error": "There goes my error"},
+        # )
+        log.info("exit create from into imageEncryption routing method")
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        log.debug("tel_Flag==="+str(tel_Falg))
+        # requestList = payload.__dict__
+        if(tel_Falg == True):
+            log.debug("Inside Telemetry Flag")
+            # telemetryPayload = {
+            #     "uniqueid": id,
+            #     "tenant": "privacy",
+            #     "apiName": image_verify.__name__,
+            #     # "portfolio": portfolio,
+            #     # "accountName": account,
+            #     # "exclusion_list": exclusionList,
+            #     "request": requestList,
+            #     "response": response
+            # }
+            # TelemetryDb.create(telemetryPayload)
+            
+            # Trigger the API call asynchronously using a separate thread
+            # with concurrent.futures.ThreadPoolExecutor() as executor:
+            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
+            log.info("******TELEMETRY REQUEST COMPLETED********")
+        return response
+        
+    except PrivacyException as cie:
+        log.error("Exception for imageEncryption")
+        log.error(cie.__dict__)
+        # ExceptionDb.create({"UUID":id,"function":"imageHashifyRouter","msg":cie.__dict__,"description":cie.__dict__})
+        er=[{"UUID":request_id_var.get(),"function":"imageHashifyRouter","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        log.error(cie, exc_info=True)
+        log.info("exit create usecase routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except NoAdminConnException:
+        raise HTTPException(
+            status_code=435,
+            detail=" Accounts and Portfolio not available with the Subscription!!",
+            headers={"X-Error": "Admin Connection is not established,"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"imageHashifyRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        er=[{"UUID":request_id_var.get(),"function":"imageHashifyRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+    
+
+
+@router.post('/privacy/privacyShield', response_model= PIIPrivacyShieldResponse)
+def privacy_shield(payload: PIIPrivacyShieldRequest,auth= Depends(auth)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into privacyShield routing method")
+    try:
+        # log.info("Entered create usecase routing method" )
+        log.debug("request payload: "+ str(payload))
+        startTime = time.time()
+        log.debug("Entered into privacyShield function")
+        response = Shield.privacyShield(payload)
+        ApiCall.delAdminList()
+        log.debug("Returned from privacyShield function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        if(response==None):
+            raise NoAccountException
+        if(response==404):
+            raise NoAdminConnException        
+        #     raise HTTPException(
+        #     status_code=430,
+        #     detail="Portfolio/Account Is Incorrect",
+        #     headers={"X-Error": "There goes my error"},
+        # )
+        # log.info("after invoking create usecase service ")
+        log.debug("response : "+ str(response))
+        log.info("exit create from privacyShield routing method")
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        log.debug("tel_Flag==="+str(tel_Falg))
+        # responseList = response.privacyCheck
+        # requestList = payload.__dict__
+        if(tel_Falg == True):
+            log.debug("Inside Telemetry Flag")
+            # telemetryPayload = {
+            #     "uniqueid": id,
+            #     "tenant": "privacy",
+            #     "apiName": "privacyshield",
+            #     # "portfolio": payload.portfolio,
+            #     # "accountName": payload.account,
+            #     # "exclusion_list": "None",
+            #     "request": requestList,
+            #     "response": responseList
+            # }
+            # TelemetryDb.create(telemetryPayload)
+            
+            # Trigger the API call asynchronously using a separate thread
+            # with concurrent.futures.ThreadPoolExecutor() as executor:
+            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
+            log.info("******TELEMETRY REQUEST COMPLETED********")
+        return response
+    except PrivacyException as cie:
+        log.error("Exception for privacyShield")
+        log.error(cie.__dict__)
+        # ExceptionDb.create({"UUID":id,"function":"privacyShield","msg":cie.__dict__,"description":cie.__dict__})
+        er=[{"UUID":request_id_var.get(),"function":"privacyShield","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        log.error(cie, exc_info=True)
+        log.info("exit create from privacyShield routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except NoAdminConnException:
+        raise HTTPException(
+            status_code=435,
+            detail=" Accounts and Portfolio not available with the Subscription!!",
+            headers={"X-Error": "Admin Connection is not established,"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"privacyShield","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        er=[{"UUID":request_id_var.get(),"function":"privacyShield","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+
+# from privacy.service.dicom_service import DICOM
+# @router.get('/privacy/pii/dicom/anonymize')
+# def image_anonymize():
+#     try:
+#         log.info("Entered create usecase routing method" )
+#         # payload={"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
+#         # log.info(str(payload))
+#         # response = service.image_anonymize(payload)
+#         response=DICOM.dicomReader()
+#         # print(response)
+        
+#         # if(response==None):
+#         #     raise HTTPException(
+#         #     status_code=430,
+#         #     detail="Portfolio/Account Is Incorrect",
+#         #     headers={"X-Error": "There goes my error"},
+#         # )
+#         log.info("after invoking create usecase service ")
+        
+#         log.info("exit create usecase routing method")
+#         return response
+        
+#     except PrivacyException as cie:
+#         log.error(cie.__dict__)
+#         log.info("exit create usecase routing method")
+#         raise HTTPException(**cie.__dict__)
+ 
+   
+@router.post('/privacy/dicom/anonymize')
+def dicom_anonymize(payload: UploadFile = File(...),auth= Depends(auth)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into readDicom routing method" )
+    try:
+        # payload={"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
+        startTime = time.time()
+        log.debug("Entered into readDicom function")
+        response =DICOMPrivacy.readDicom(payload)
+        log.debug("Returned from readDicom function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        if(response==None):
+            raise NoAccountException
+        if(response==404):
+            raise NoAdminConnException  
+        #     raise HTTPException(
+        #     status_code=430,
+        #     detail="Portfolio/Account Is Incorrect",
+        #     headers={"X-Error": "There goes my error"},
+        # )
+     
+        
+        log.info("exit create from readDicom routing method")
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        log.debug("tel_Flag==="+str(tel_Falg))
+        # responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
+        # requestList = payload.__dict__
+        if(tel_Falg == True):
+            log.debug("Inside Telemetry Flag")
+            # telemetryPayload = {
+            #     "uniqueid": id,
+            #     "tenant": "privacy",
+            #     "apiName": "DICOMIMAGE",
+            #     # "portfolio": "None",
+            #     # "accountName": "None",
+            #     # "exclusion_list": "None",
+            #     "request": requestList,
+            #     "response": responseList
+            # }
+            # TelemetryDb.create(telemetryPayload)
+            
+            # Trigger the API call asynchronously using a separate thread
+            # with concurrent.futures.ThreadPoolExecutor() as executor:
+            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
+            log.info("******TELEMETRY REQUEST COMPLETED********")
+        return response
+        
+    except PrivacyException as cie:
+        log.error("Exception for readDicom")
+        log.error(cie.__dict__)
+        # ExceptionDb.create({"UUID":id,"function":"DICOMAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
+        er=[{"UUID":request_id_var.get(),"function":"DICOMAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        log.error(cie, exc_info=True)
+        log.info("exit create from readDicom routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except NoAdminConnException:
+        raise HTTPException(
+            status_code=435,
+            detail=" Accounts and Portfolio not available with the Subscription!!",
+            headers={"X-Error": "Admin Connection is not established,"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"DICOMAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        er=[{"UUID":request_id_var.get(),"function":"DICOMAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+
+@fileRouter.post('/privacy-files/excel/anonymize')
+def logo_anonymize(excel: UploadFile = File(...),auth= Depends(auth)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into excelanonymize routing method" )
+    try:
+        payload={"excel":excel}
+        print("payload==",payload)
+        # print("type==",excel.file.content_type)
+        startTime = time.time()
+        log.debug("Entered into excelanonymize function")
+        response = Excel.excelanonymize(payload)
+        log.debug("Returned from excelanonymize function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        if(response==None):
+            raise NoAccountException
+        if(response==404):
+            raise NoAdminConnException  
+        
+        #     raise HTTPException(
+        #     status_code=430,
+        #     detail="Portfolio/Account Is Incorrect",
+        #     headers={"X-Error": "There goes my error"},
+        # )
+       
+        log.info("exit create from excelanonymize routing method")
+        log.debug("response===="+str(response))
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        log.debug("tel_Flag==="+str(tel_Falg))
+        # responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
+        # requestList = payload.__dict__
+        if(tel_Falg == True):
+            log.debug("Inside Telemetry Flag")
+            # telemetryPayload = {
+            #     "uniqueid": id,
+            #     "tenant": "privacy",
+            #     "apiName": "Excel_Anonymize",
+            #     # "portfolio": "None",
+            #     # "accountName": "None",
+            #     # "exclusion_list": "None",
+            #     "request": requestList,
+            #     "response": responseList
+            # }
+            # TelemetryDb.create(telemetryPayload)
+            
+            # Trigger the API call asynchronously using a separate thread
+            # with concurrent.futures.ThreadPoolExecutor() as executor:
+            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
+            log.info("******TELEMETRY REQUEST COMPLETED********")
+        return FileResponse(response,media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+        # return response
+        
+    except PrivacyException as cie:
+        log.error("Exception for excelanonymize")
+        log.error(cie.__dict__)
+        # ExceptionDb.create({"UUID":id,"function":"excelAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
+        er=[{"UUID":request_id_var.get(),"function":"excelAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        log.error(cie, exc_info=True)
+        log.info("exit create usecase routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except NoAdminConnException:
+        raise HTTPException(
+            status_code=435,
+            detail=" Accounts and Portfolio not available with the Subscription!!",
+            headers={"X-Error": "Admin Connection is not established,"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"excelAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        er=[{"UUID":request_id_var.get(),"function":"excelAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+
+## PAYLOAD CHANGED TO ACCEPT TEXT IN A STRUCTURED FORMAT AND GET RESPONSE FOR THE SAME
+from starlette.responses import PlainTextResponse
+@router.post('/privacy/code/anonymize',response_class=PlainTextResponse)
+async def code_redaction(payload_text: str = Body(..., media_type="text/plain", description="The code to be anonymized"),auth= Depends(auth)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into textner routing method")
+    try:
+        log.debug("payload==" + str(payload_text))
+        
+        startTime = time.time()
+        log.debug("Entered into textner function")
+        response = codeNer.codeText(payload_text,model, tokenizer)
+        log.debug("Returned from textner function")
+        
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken " + str(totalTime))
+        log.debug("response" + str(response))
+        
+        if response is None:
+            raise NoAccountException
+        
+        log.info("exit create from textner routing method")
+        # Return the response as plain text, maintaining the format
+        return PlainTextResponse(content=response)
+    except PrivacyException as cie:
+        log.error("Exception for code anonymize")
+        raise cie
+
+from io import BytesIO
+
+@router.post('/privacy/codefile/anonymize')
+async def code_anonymize(code_file: UploadFile = File(...)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into filener routing method" )
+    try:
+        # Read the file content from the UploadFile object
+        code_content = await code_file.read()
+        print("code_content==",code_content)
+        # Perform code redaction
+        startTime = time.time()
+        log.debug("Entered into filener function")
+        redacted_content, output_code_file = codeNer.codeFile(code_content, code_file.filename,model, tokenizer)
+        log.debug("Returned from filener function")
+        if isinstance(redacted_content, str):
+            redacted_content = redacted_content.encode('utf-8')
+        print(redacted_content,"REDACTED CONTENT")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        headers = {
+            "Content-Disposition": f"attachment; filename={output_code_file}",
+            "Access-Control-Expose-Headers": "Content-Disposition"
+        }
+
+        # Delete the uploaded file
+        await code_file.close()
+        # filepath = os.path.join('', code_file.filename)
+        output_code_file = os.path.splitext(code_file.filename)[0] + "_redacted" + os.path.splitext(code_file.filename)[1]
+        os.remove(output_code_file)
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        # responseList = list(map(lambda obj: obj.__dict__, response.PIIEntities))
+        # requestList = payload.__dict__
+        if(tel_Falg == True):
+            log.debug("Inside Telemetry Flag")
+            # telemetryPayload = {
+            #     "uniqueid": id,
+            #     "tenant": "privacy",
+            #     "apiName": code_anonymize.__name__,
+            #     # "portfolio": "None",
+            #     # "accountName": "None",
+            #     # "exclusion_list": "None",
+            #     "request": requestList,
+            #     "response": responseList
+            # }
+            # TelemetryDb.create(telemetryPayload)
+            
+            # Trigger the API call asynchronously using a separate thread
+            # with concurrent.futures.ThreadPoolExecutor() as executor:
+            #     executor.submit(send_telemetry_request, privacy_telemetry_request)
+            log.info("******TELEMETRY REQUEST COMPLETED********")
+
+        # Return the redacted code content as a response with the correct filename
+        return StreamingResponse(BytesIO(redacted_content), media_type="application/octet-stream", headers=headers)
+    except PrivacyException as cie:
+        log.error("Exception for filener")
+        log.error(cie, exc_info=True)
+        # ExceptionDb.create({"UUID":id,"function":"codeFileAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
+        er=[{"UUID":request_id_var.get(),"function":"codeFileAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise cie
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"codeFileAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        er=[{"UUID":request_id_var.get(),"function":"codeFileAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+
+
+
+
+# # from privacy.service.test import Test
+# @router.get('/privacy/pii/video/anonymizea')
+# async def image_analyze():
+#     try:
+#         log.info("Entered create usecase routing method" )
+#         # payload={"image":image,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
+#         # response =VideoAnalyzer.anonymize(payload)
+#         # print(response)
+#         # if(response==None):
+#         #     raise HTTPException(
+#         #     status_code=430,
+#         #     detail="Portfolio/Account Is Incorrect",
+#         #     headers={"X-Error": "There goes my error"},
+#         # )
+#         # log.info("after invoking create usecase service ")
+#         # x=[]
+#         x=Test.work()
+#         # for i in x:
+#         #     print(i)
+#         # log.info("exit create usecase routing method")
+#         return StreamingResponse(x,media_type="plain/text")
+        
+        
+#     except PrivacyException as cie:
+#         log.error(cie.__dict__)
+#         log.info("exit create usecase routing method")
+#         raise HTTPException(**cie.__dict__)
+# app=FastAPI()
+# cc=set()
+# @app.websocket("/ws")
+# async def check(websocket:WebSocket):
+#     await websocket.accept()
+#     cc.add(websocket)
+#     try:
+#         while True:
+#             m="asdasdasdasdasd"
+#             await websocket.send_text(m)
+#             await asyncio.sleep(1)
+#     except:
+#         cc.remove(websocket)
+
+
+
+from privacy.service.diffrentialPrivacy import DiffPrivacy
+@router.post('/privacy/DifferentialPrivacy/file')
+def diff_privacy_file(dataset: UploadFile = File(...),auth= Depends(auth)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into uploadFIle routing method" )
+    try:
+        # payload={"excel":excel}
+        # print("payload==",payload)
+        # print("type==",excel.file.content_type)
+        startTime = time.time()
+        log.debug("Entered into uploadFIle function")
+        response = DiffPrivacy.uploadFIle(dataset)
+        log.debug("Returned from uploadFIle function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        if(response==None):
+            raise NoAccountException
+        #     raise HTTPException(
+        #     status_code=430,
+        #     detail="Portfolio/Account Is Incorrect",
+        #     headers={"X-Error": "There goes my error"},
+        # )
+        # log.info("after invoking create usecase service ")
+        
+        log.info("exit create from uploadFIle routing method")
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        # print("tel_Flag===",tel_Falg)
+        # if(tel_Falg == True):
+        #     print("Inside Telemetry Flag")
+        #     
+        #     # Trigger the API call asynchronously using a separate thread
+        #     with concurrent.futures.ThreadPoolExecutor() as executor:
+            #    executor.submit(send_telemetry_request, privacy_telemetry_request)
+        return response
+    except PrivacyException as cie:
+        log.error("Exception for uploadFIle")
+        log.error(cie.__dict__)
+        # ExceptionDb.create({"UUID":id,"function":"diffPrivacyFileRouter","msg":cie.__dict__,"description":cie.__dict__})
+        er=[{"UUID":request_id_var.get(),"function":"diffPrivacyFileRouter","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        log.error(cie, exc_info=True)
+        log.info("exit create from uploadFIle routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"diffPrivacyFileRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        er=[{"UUID":request_id_var.get(),"function":"diffPrivacyFileRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+    
+from privacy.service.diffrentialPrivacy import DiffPrivacy
+@router.post('/privacy/DifferentialPrivacy/anonymize')
+def diff_privacy_anonymize(suppression:Optional[str]=Form(""),noiselist:Optional[str]=Form(""),binarylist:Optional[str]=Form(""),rangeList:Optional[str]=Form(""),auth= Depends(auth)):
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into diffPrivacy routing method" )
+    try:
+        # log.info("Entered create usecase routing method" )
+        # payload={"excel":excel}
+        # print("payload==",payload)
+        payload={"suppression":suppression,"noiselist":noiselist,"binarylist":binarylist,"rangelist":rangeList}
+        # print("type==",excel.file.content_type)
+        startTime = time.time()
+        log.debug("Entered into diffPrivacy function")
+        response = DiffPrivacy.diffPrivacy(payload)
+        log.debug("Returned from diffPrivacy function")
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        if(response==None):
+            raise NoAccountException
+        #     raise HTTPException(
+        #     status_code=430,
+        #     detail="Portfolio/Account Is Incorrect",
+        #     headers={"X-Error": "There goes my error"},
+        # )
+        # log.info("after invoking create usecase service ")
+        
+        log.info("exit create from diffPrivacy routing method")
+        log.debug("res===="+str(response))
+        # telFlagData = TelemetryFlag.findall({"Module":"Privacy"})[0]
+        # tel_Falg = telFlagData["TelemetryFlag"]
+        # print("tel_Flag===",tel_Falg)
+        # if(tel_Falg == True):
+        #     print("Inside Telemetry Flag")
+        #     
+        #     # Trigger the API call asynchronously using a separate thread
+        #     with concurrent.futures.ThreadPoolExecutor() as executor:
+            #    executor.submit(send_telemetry_request, privacy_telemetry_request)
+        # return response
+        headers = {"Content-Disposition": f"attachment; filename=x.csv"}
+        return StreamingResponse(response, media_type="text/csv", headers=headers)
+    except PrivacyException as cie:
+        log.error("Exception for diffPrivacy")
+        log.error(cie.__dict__)
+        # ExceptionDb.create({"UUID":id,"function":"diffPrivacyAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__})
+        er=[{"UUID":request_id_var.get(),"function":"diffPrivacyAnonimyzeRouter","msg":cie.__dict__,"description":cie.__dict__}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        log.error(cie, exc_info=True)
+        log.info("exit create usecase routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # er={"UUID":request_id_var.get(),"function":"diffPrivacyAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er=[{"UUID":request_id_var.get(),"function":"diffPrivacyAnonimyzeRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)}]
+        er.extend(error_dict[request_id_var.get()] if request_id_var.get() in error_dict else [])
+        logobj = {"uniqueid":id,"error":er}
+        
+        if len(er)!=0:
+            thread = threading.Thread(target=Telemetry.error_telemetry_request, args=(logobj,id))
+            thread.start()
+            
+            if request_id_var.get() in error_dict:
+                del error_dict[id] 
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})
+   
+@fileRouter.post('/privacy-files/video/anonymize')
+async def videoPrivacy(ocr: str = Query('Tesseract', enum=['Tesseract',"EasyOcr","ComputerVision"]),magnification:str=Form(...),rotationFlag:str=Form(...),video: UploadFile = File(...),portfolio:Optional[str]=Form(None),account:Optional[str]=Form(None),exclusionList:Optional[str]=Form(None),auth= Depends(auth)):
+    # payload = {"video": video, "easyocr": ocr}
+    id = uuid.uuid4().hex
+    request_id_var.set(id)
+    log.info("Entered create into image_anonymize routing method" )
+    try:
+        payload={"easyocr":ocr,"mag_ratio":magMap[magnification],"rotationFlag":magMap[rotationFlag],"video":video,"portfolio":portfolio,"account":account,"exclusion":exclusionList}
+        startTime = time.time()
+        response = await VideoService.videoPrivacy(payload)
+        endTime = time.time()
+        totalTime = endTime - startTime
+        log.info("Total Time taken "+str(totalTime))
+        if(response==None):
+            raise NoAccountException
+        
+        
+        log.info("exit create from image_anonymize routing method")
+        return response
+        
+    except PrivacyException as cie:
+        log.error("Exception for video_privacy")
+        log.error(cie.__dict__)
+        # ExceptionDb.create({"UUID":id,"function":"videoPrivacyRouter","msg":cie.__dict__,"description":cie.__dict__})
+       
+        log.error(cie, exc_info=True)
+        log.info("exit create usecase routing method")
+        raise HTTPException(**cie.__dict__)
+    except NoAccountException:
+        raise HTTPException(
+            status_code=430,
+            detail="Portfolio/Account Is Incorrect",
+            headers={"X-Error": "There goes my error"},
+        )
+    except Exception as e:
+        log.error(str(e))
+        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"videoPrivacyRouter","msg":str(e),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+        raise HTTPException(
+            status_code=500,
+            detail="Please check with administration!!",
+            headers={"X-Error": "Please check with administration!!"})

src/privacy/service/Video_service.py

@@ -0,0 +1,207 @@
+'''
+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.
+'''
+
+import base64
+import io
+from typing import Tuple
+import cv2
+from PIL import Image
+from privacy.service.imagePrivacy import AttributeDict, ImagePrivacy
+import numpy as np
+from privacy.config.logger import request_id_var
+from privacy.config.logger import CustomLogger
+import os
+import shutil
+import threading
+import time
+import uuid
+
+log = CustomLogger()
+
+path="../video/"
+error_dict={}
+
+class VideoService:
+        def frameAnonymization(payload,frame,indx,procFrame,request_id):
+                try:
+                        # request_id_var.set(request_id)
+                        id = uuid.uuid4().hex
+                        request_id_var.set(id)
+                        ipath=path+str(request_id)+"/"+str(indx)+".jpg"
+                        # print(ipath)
+                        # Convert the frame to PIL Image
+                        # base64.b64encode(frame).decode()
+                        # Image.open(base64.b64encode(frame).decode())
+                        # print(type(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)))
+                        imagef = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+                        imagef.save(ipath)
+                        # image=open("test.jpg","rb")
+                        # print(type(imagef))
+                        image={"file":ipath}
+                        image=AttributeDict(image)
+                        payload["image"]=image
+                        # ocr=None
+                        # global imageAnalyzerEngine
+
+                        # imageAnalyzerEngine = ImageAnalyzerEngine(analyzer_engine=analyzer,ocr=ocr)  
+                        # imageRedactorEngine = ImageRedactorEngine(image_analyzer_engine=imageAnalyzerEngine)
+                        # redacted_image = imageRedactorEngine.redact(image, (255, 192, 203))
+                        # payload={"easyocr":"Tesseract","mag_ratio":False,"rotationFlag":False,"image":image,"portfolio":None,"account":None,"exclusion":None}
+
+                        redacted_image=ImagePrivacy.image_anonymize(payload)
+                        decoded_bytes = base64.b64decode(redacted_image)
+
+                        # Create a BytesIO object to simulate a file-like object
+                        bio = io.BytesIO(decoded_bytes)
+
+                        # Use OpenCV (assuming it's an image) or other libraries to load the image from the BytesIO object
+                        img = cv2.imdecode(np.fromstring(bio.getvalue(), np.uint8), cv2.IMREAD_COLOR)
+
+                        # Convert the PIL Image back to OpenCV frame
+                        frame = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+                        procFrame[indx]=frame
+                        return (frame,indx)
+                        # Write the frame into the file 'output.avi'
+                        # out.write(frame)
+
+                    # else:
+                except Exception as e:
+                        log.error(str(e))
+                        log.error("Line No:"+str(e.__traceback__.tb_lineno))
+                        log.error(str(e.__traceback__.tb_frame))
+                        # error_dict[request_id_var.get()].append({"UUID":request_id_var.get(),"function":"VideoAnalyzeMainFunction","msg":str(e.__class__.__name__),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+                        # ExceptionDb.create({"UUID":request_id_var.get(),"function":"textAnalyzeMainFunction","msg":str(e.__class__.__name__),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+                        raise Exception(e)
+                    #     break
+
+
+        async def videoPrivacy(payload) -> Tuple[str, str]:
+            error_dict[request_id_var.get()]=[]
+            try:     
+                  payload=AttributeDict(payload)
+                  upload_file = payload.video
+                  filename=upload_file.filename
+
+                  id = uuid.uuid4().hex
+                  request_id_var.set(id)
+                  _path=path+str(id)
+                  if(not os.path.exists(_path)):
+                    os.makedirs(_path)
+                  video_data = await upload_file.read()
+                  s=time.time()
+                  temp_file_path = path+"input.pm4"
+                  output_file_path =path+"output3.mp4"
+                  with open(temp_file_path, "wb") as temp_file:
+                      temp_file.write(video_data)
+                  video = cv2.VideoCapture(temp_file_path)
+                  # Get video properties
+                  width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
+                  height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
+                  fps = video.get(cv2.CAP_PROP_FPS)
+                  sampling_rate=int(fps*0.3)
+                  # Define the codec and create a VideoWriter object
+                  fourcc = cv2.VideoWriter_fourcc(*'XVID')
+                  out = cv2.VideoWriter(output_file_path, fourcc, fps, (width, height))
+                  frameList=[]
+                  indxList=[]
+                  first=True
+                  count=0
+                  last_frame=None
+                  log.debug("samp "+str(sampling_rate))
+
+
+                  # audio_fps = video.get(cv2.CAP_PROP_FPS)
+                  # fourcc = int(video.get(cv2.CAP_PROP_FOURCC)) 
+                  # print("aud",audio_fps,fourcc)
+                  # sampling_rate=1
+                  while(video.isOpened()):
+                      ret, frame = video.read()
+                      # print(ret)
+                      if ret==True:
+                          if first:
+                                frameList.append(frame)
+                                indxList.append(count)
+                                first=False          
+                          else:
+                            if count % sampling_rate == 0:
+                              frameList.append(frame)
+                              indxList.append(count)
+                            # else:
+                            #   frameList.append(None)
+                          last_frame=frame
+                          count+=1    
+                      else:
+                          break
+                  if(count%sampling_rate!=0):
+                    frameList.append(last_frame)
+                    indxList.append(count)
+                  log.debug("totalFrame:"+str(count))
+                  # print(indxList,len(indxList))       
+                  log.debug("after sampling"+str(len(frameList)))
+                  rcount=len(frameList)
+                  framecopy=frameList.copy()
+                  procFrame=[None]*(count+1)
+                  # print(len(procFrame))
+                  # indx=0
+                  while framecopy:
+                      threads = []
+                      for _ in range(min(6, len(framecopy))):  # Limit calls to remaining arguments
+                        arg = framecopy.pop(0)  # Get the first argument and remove it
+                        indx=indxList.pop(0)
+                        thread = threading.Thread(target=VideoService.frameAnonymization, args=(payload,arg,indx,procFrame,request_id_var.get()))
+                        thread.start()
+                        threads.append(thread)
+                        # print(thread)
+                        indx+=1
+                      # Wait for all threads in the current set to finish
+
+                      log.debug("remaining:"+str(rcount-len(framecopy))+"/"+str(rcount))
+                      for thread in threads:
+                        thread.join()   
+                  # print("===",procFrame)     
+                  # Release everything when job is finished
+                  # print(procFrame)
+                  lstFrame=None
+                  for frm in procFrame:
+                      # print(frm,frm.any())
+                      # print(frm,frm.all())
+                      if(lstFrame is None):
+                          lstFrame=frm
+                      if(frm is not None):
+                        lstFrame=frm 
+                      else:
+                          frm=lstFrame
+                      out.write(frm)
+                  video.release()
+                  out.release()
+                  # Remove temporary file
+                  # os.remove(temp_file_path)
+                  # Read the processed video file
+                  with open(output_file_path, "rb") as video_file:
+                      video_data = video_file.read()
+                  # Convert the video to base64
+                  video_str = base64.b64encode(video_data).decode()
+                  # Remove the output file
+                  # os.remove(output_file_path)
+                #   log.debug(path)
+                  shutil.rmtree(_path)
+                #   log.debug("====",time.time()-s)
+                  del procFrame
+                  del indxList
+                  del frameList
+                  return video_str
+
+            except Exception as e:
+                log.error(str(e))
+                log.error("Line No:"+str(e.__traceback__.tb_lineno))
+                log.error(str(e.__traceback__.tb_frame))
+                error_dict[request_id_var.get()].append({"UUID":request_id_var.get(),"function":"VideoAnonymizeMainFunction","msg":str(e.__class__.__name__),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+                # ExceptionDb.create({"UUID":request_id_var.get(),"function":"textAnalyzeMainFunction","msg":str(e.__class__.__name__),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+                raise Exception(e)

src/privacy/service/__init__.py

@@ -0,0 +1,51 @@
+import contextvars
+from presidio_analyzer import Pattern, PatternRecognizer, AnalyzerEngine, RecognizerRegistry,predefined_recognizers
+from presidio_anonymizer import AnonymizerEngine, DeanonymizeEngine
+from presidio_anonymizer.entities import (RecognizerResult,
+    OperatorResult,
+    OperatorConfig)
+from privacy.config.logger import CustomLogger
+from presidio_image_redactor import ImageRedactorEngine,ImageAnalyzerEngine,ImagePiiVerifyEngine       
+from presidio_image_redactor import DicomImageRedactorEngine
+
+from privacy.util.encrypt import EncryptImage
+from privacy.config.logger import CustomLogger
+log = CustomLogger()
+print("===========init==========")
+error_dict={}
+admin_par={}
+session_dict = contextvars.ContextVar('session_dict', default={})
+
+# Example usage:
+def update_session_dict(key, value):
+    session_dict.get()[key] = value
+
+def get_session_dict():
+    return session_dict.get()
+
+class AttributeDict(dict):
+    __getattr__ = dict.__getitem__
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+    
+registry = RecognizerRegistry()
+# log.info("============2a")
+# analyzer = AnalyzerEngine(registry=registry)
+# log.debug("============2b")
+anonymizer = AnonymizerEngine()
+# Create NLP engine based on configuration
+# flair_recognizer = (
+#     FlairRecognizer()
+# ) 
+# registry.add_recognizer(flair_recognizer)
+# provider = NlpEngineProvider(nlp_configuration=configuration)
+analyzer = AnalyzerEngine(registry=registry)
+imageAnalyzerEngine = ImageAnalyzerEngine(analyzer_engine=analyzer)
+imageRedactorEngine = ImageRedactorEngine(image_analyzer_engine=imageAnalyzerEngine)
+imagePiiVerifyEngine = ImagePiiVerifyEngine(image_analyzer_engine=imageAnalyzerEngine) 
+encryptImageEngin=EncryptImage(image_analyzer_engine=imageAnalyzerEngine)
+deanonymizer = DeanonymizeEngine()
+DicomEngine = DicomImageRedactorEngine()
+registry.load_predefined_recognizers()
+
+    

src/privacy/service/api_req.py

@@ -0,0 +1,88 @@
+import os
+from dotenv import load_dotenv
+from privacy.config.logger import CustomLogger,request_id_var
+log = CustomLogger()
+from privacy.service.__init__ import *
+import time
+import requests
+load_dotenv()
+class ApiCall:
+    # records=[]
+    # encryptionList=[]
+    # scoreTreshold=    0.0
+    def request(data):
+        try:
+            # admin_par[request_id_var]={}
+            # raise Exception() 
+            # print("==================",os.getenv("ADMIN_CONNECTION"))
+            # print("==================",os.getenv("ADMIN_CONNECTION")=="False")
+            
+            if(os.getenv("ADMIN_CONNECTION")=="False" or os.getenv("ADMIN_CONNECTION")=="false"):
+           
+                # print("--------------------------------------------------------------")
+                return 404
+            # ApiCall.records.clear()
+            # ApiCall.encryptionList.clear()
+            payload=AttributeDict({"portfolio":data.portfolio,"account":data.account})
+            
+            # payload={"accName":"Infosys","subAccName":"Impact"}
+            api_url = os.getenv("PRIVADMIN_API")
+            
+            # print(api_url)
+            t=time.time()
+            
+            # aurl="http://10.66.155.13:30016/api/v1/rai/admin/PrivacyDataList"
+            aurl=api_url
+            # log.debug(aurl)
+            # log.debug(str(type(aurl)))
+            log.debug("Calling Admin Api  ======")
+            # log.debug("api payload:"+str(payload))
+            # print(payload)
+            response1 = requests.post(
+                url=aurl
+                , headers={'Content-Type': "application/json",
+                           'accept': "application/json"}
+                , json=payload
+                )
+            # print(response1.content[0])
+            # response1=httpx.post(aurl, json=payload)
+            # response1=httpx.post('http://10.66.155.13:30016/api/v1/rai/admin/PrivacyDataList', json=payload)
+            # log.debug("response="+str(response1))
+            # log.debug("response11="+str(response1.text))
+            # response1=PrivacyData.getDataList(payload)
+            entityType,datalist,preEntity,records,encryptionList,scoreTreshold=response1.json()["datalist"]
+            # print("=========================",time.time()-t)
+            log.debug("data fetched")
+            if(len(records)==0):
+                return None
+            log.debug("entityType="+str(entityType))
+            admin_par[request_id_var.get()]={"encryptionList":encryptionList,"records":records,"scoreTreshold":scoreTreshold[0]}
+            # print("===============",len(admin_par))
+            # ApiCall.encryptionList.extend(encryptionList)
+            # ApiCall.records.extend(records)
+            # ApiCall.scoreTreshold=scoreTreshold[0]
+            return(entityType,datalist,preEntity)
+        except Exception as e:
+            log.error(str(e))
+            log.error("Line No:"+str(e.__traceback__.tb_lineno))
+            log.error(str(e.__traceback__.tb_frame))
+            # print("------------------------------",request_id_var.get())
+            # ExceptionDb.create({"UUID":request_id_var.get(),"function":"ApiRequestFunction","msg":str(e.__class__.__name__),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+            error_dict[request_id_var.get()].append({"UUID":request_id_var.get(),"function":"ApiRequestFunction","msg":str(e.__class__.__name__),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+            # print("err",error_dict,error_dict[request_id_var.get()])
+            
+            return Exception(e)
+            # raise Exception(e)
+
+  
+        # record=[ele for ele in records if ele.RecogName=="PASSPORT"][0]  
+    
+    def getRecord(name):
+        # log.debug("name="+str(name))
+        # log.debug("ApiCall.records="+str(ApiCall.records))
+        record=[ele for ele in admin_par[request_id_var.get()]["records"] if ele["RecogName"]==name][0]
+        return record
+    def delAdminList():
+        id=request_id_var.get()
+        if id in admin_par:
+                del admin_par[id]

src/privacy/service/azureComputerVision.py

@@ -0,0 +1,137 @@
+'''
+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.
+'''
+
+# from privacy.util.encrypt import EncryptImage
+
+from presidio_image_redactor import ImageRedactorEngine,ImageAnalyzerEngine,ImagePiiVerifyEngine,OCR
+# from privacy.service import easyocr_analyzer       
+from dotenv import load_dotenv
+from privacy.config.logger import CustomLogger
+# pytesseract.pytesseract.tesseract_cmd = r"C:\Users\amitumamaheshwar.h\AppData\Local\Programs\Tesseract-OCR"
+import time
+load_dotenv()
+import os
+import sys
+import requests
+
+from PIL import Image
+from io import BytesIO
+
+log = CustomLogger()
+
+# log = CustomLogger()
+# output_type = easyocr.Reader(['en'],model_storage_directory=r"privacy/util/model",download_enabled=False)
+        
+class AttributeDict(dict):
+    __getattr__ = dict.__getitem__
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+class Data:
+    encrypted_text=[]
+    
+apikey=os.getenv("API_KEY")
+apiendpint=os.getenv("API_ENDPOINT")
+# image_path=r"C:\WORK\GIT\responsible-ai-admin\responsible-ai-admin\src\rai_admin\temp\MicrosoftTeams-image (4).png"
+# # Read the image into a byte array
+# image_data = open(image_path, "rb").read()
+# Set Content-Type to octet-stream
+headers = {'Ocp-Apim-Subscription-Key': apikey, 'Content-Type': 'application/octet-stream'}
+params = {'language': 'en', 'detectOrientation': 'true','features':['read']}
+class ComputerVision(OCR):
+
+    def process(a):
+        return a
+
+            
+        
+        
+    # def perform_ocr(self, image: object, **kwargs) -> dict:
+    #     # output_type = easyocr.Reader(['en'])
+    #     s=time.time()
+    #     # response(code)
+        
+    #     textmap={"text":[],"left":[],"top":[],"width":[],"height":[],"conf":[]}
+    #     buffer = BytesIO()
+
+    #     # Save the image to the in-memory buffer in PNG format
+    #     image.save(buffer, "PNG")
+
+    #     # Get the binary data from the buffer (seek to the beginning)
+    #     binary_data = buffer.getvalue()
+    #     image_data = binary_data
+    #     # put the byte array into your post request
+    #     response = requests.post(apiendpint, headers=headers, params=params, data = image_data)
+
+    #     response.raise_for_status()
+
+    #     analysis = response.json()
+    #     line_infos = [region["lines"] for region in analysis["regions"]]
+    #     word_infos = []
+    #     for line in line_infos:
+    #         for word_metadata in line:
+    #             for word_info in word_metadata["words"]:
+    #                 word_infos.append(word_info)
+
+    #     for val in word_infos:
+    #         boxval=val["boundingBox"].split(',')
+    #         textmap["text"].append(val["text"])
+    #         textmap["left"].append(int(boxval[0]))
+    #         textmap["top"].append(int(boxval[1]))
+    #         textmap["width"].append(int(boxval[2]))
+    #         textmap["height"].append(int(boxval[3]))
+    #         # textmap["conf"].append(val["conf"])
+    #         # text.append(val["text"])
+    #         # left.append(min(val['coordinates'][0][0],val["coordinates"][3][0]))
+    #         # top.append(min(val['coordinates'][0][1],val["coordinates"][1][1]))
+    #         # width.append(abs(val['coordinates'][1][0]-val["coordinates"][0][0]))
+    #         # height.append(abs(val['coordinates'][3][1]-val["coordinates"][0][1]))
+    #         # conf.append(val["conf"])
+    #     print(textmap)
+    #     log.warn("time======="+str(time.time()-s))
+    #     return textmap
+            
+
+    def perform_ocr(self, image: object, **kwargs) -> dict:
+        # output_type = easyocr.Reader(['en'])
+        s=time.time()
+        # response(code)
+        
+        textmap={"text":[],"left":[],"top":[],"width":[],"height":[],"conf":[]}
+        buffer = BytesIO()
+
+        # Save the image to the in-memory buffer in PNG format
+        image.save(buffer, "PNG")
+
+        # Get the binary data from the buffer (seek to the beginning)
+        binary_data = buffer.getvalue()
+        image_data = binary_data
+        # put the byte array into your post request
+        response = requests.post(apiendpint, headers=headers, params=params, data = image_data)
+
+        response.raise_for_status()
+
+        analysis = response.json()
+        print(analysis)
+        line_infos = [region["lines"] for region in analysis["readResult"]["blocks"]]
+        textmap={"text":[],"left":[],"top":[],"width":[],"height":[],"conf":[]}
+        for line in line_infos:
+            for word_metadata in line:
+                for val in word_metadata["words"]:
+                    # word_infos.append(val)
+                    textmap["text"].append(val["text"])
+                    textmap["left"].append(min(val['boundingPolygon'][0]['x'],val["boundingPolygon"][3]['x']))
+                    textmap["top"].append(min(val['boundingPolygon'][0]['y'],val["boundingPolygon"][1]['y']))
+                    textmap["width"].append(abs(val['boundingPolygon'][1]['x']-val["boundingPolygon"][0]['x']))
+                    textmap["height"].append(abs(val['boundingPolygon'][3]['y']-val["boundingPolygon"][0]['y']))
+                    textmap["conf"].append(val["confidence"])
+        print(textmap)
+        log.warn("time======="+str(time.time()-s))
+        return textmap
+            

src/privacy/service/code_detect_service.py

@@ -0,0 +1,51 @@
+'''
+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.
+'''
+
+
+import base64
+import json
+import io, base64
+from PIL import Image
+import requests
+import pandas as pd
+from privacy.mappers.mappers import *
+import os
+
+from privacy.config.logger import CustomLogger
+from privacy.util.code_detect import *
+from privacy.util.code_detect.regexdetection import *
+import json
+from privacy.util.code_detect.ner.pii_inference.netcustom import code_detect_ner
+log = CustomLogger()
+
+class AttributeDict(dict):
+    __getattr__ = dict.__getitem__
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+
+class CodeDetect:
+    def codeDetectRegex(payload)->PIICodeDetectRequest:
+        payload=AttributeDict(payload)
+        print("Text===",payload)
+        #finalpayload=str(payload)
+        #ouputjson=json.loads(payload)
+        output_code=code_detect.codeDetectRegex(payload.inputText)
+        print("output_code===",output_code)
+        return output_code
+    
+    def codeDetectNerText(payload)->PIICodeDetectRequest:
+        payload=AttributeDict(payload)
+        print("Text===",payload)
+        #finalpayload=str(payload)
+        #ouputjson=json.loads(payload)
+        output_code=code_detect_ner.textner(payload.inputText)
+        print("output_code===",output_code)
+        return output_code  

src/privacy/service/dicomPrivacy.py

@@ -0,0 +1,70 @@
+'''
+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.
+'''
+import base64
+import io
+import matplotlib.pyplot as plt
+import pydicom
+from PIL import Image
+from privacy.service.__init__ import *
+from privacy.service.api_req import ApiCall
+from privacy.config.logger import request_id_var
+
+
+
+class DICOMPrivacy:
+    def dcmToPng(dcmObj):
+        plt.clf()
+        plt.imshow(dcmObj.pixel_array,cmap=plt.cm.bone)
+        plt.axis('off')
+        buffer=io.BytesIO()
+        plt.savefig(buffer,format='png', bbox_inches='tight', pad_inches=0)
+        buffer.seek(0)
+        return base64.b64encode(buffer.getvalue())
+        
+    
+   
+    
+    def readDicom(payload):
+        error_dict[request_id_var.get()]=[]
+        log.debug("Entering in readDicom function")
+        try:
+            # print(type(payload))
+            # print(payload.file)
+          
+            # predefined_recognizers.data_recognizer.DataList.entity.clear()
+            # predefined_recognizers.data_recognizer.DataList.resetData()
+            DicomEngine = DicomImageRedactorEngine()
+            dicom_instance = pydicom.dcmread(payload.file)
+            # print(type(dicom_instance))
+            redacted_dicom_instance = DicomEngine.redact(dicom_instance, fill="contrast") 
+            original=DICOMPrivacy.dcmToPng(dicom_instance)
+            redacted=DICOMPrivacy.dcmToPng(redacted_dicom_instance)
+
+            obj={"original":original,"anonymize":redacted}
+            log.debug("Returning from readDicom function")
+            return obj
+  
+        except Exception as e:
+            log.error(str(e))
+            log.error("Line No:"+str(e.__traceback__.tb_lineno))
+            log.error(str(e.__traceback__.tb_frame))
+            error_dict[request_id_var.get()].append({"UUID":request_id_var.get(),"function":"readDICOMFunction","msg":str(e.__class__.__name__),"description":str(e)+"Line No:"+str(e.__traceback__.tb_lineno)})
+            raise Exception(e)
+  
+
+
+
+class saveImage:
+    def saveImg(img_data):
+        
+        
+        with open("file.png", "wb") as fh:
+            fh.write(base64.decodebytes(img_data))
+