unitypredict-engines 0.0.1__py3-none-any.whl

unitypredict_engines/Models.py

@@ -0,0 +1,110 @@
+from enum import Enum
+import json
+import attr
+
+class EngineResults:
+    OutcomeValues: dict = {}
+    Outcomes: dict = {}
+
+    def __init__(self):
+        self.OutcomeValues = dict()
+        self.Outcomes = dict()
+
+    def toJSON(self):
+        return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
+
+class OutcomePrediction:
+    Probability = 0.0
+    Value = None
+
+    def __init__(self):
+        self.Probability = 0.0
+        self.Value = None
+
+class DataTypes(str, Enum):
+    Boolean = 'Boolean'
+    Integer = 'Integer'
+    Float = 'Float'
+    String = 'String'
+    File = 'File'
+    Tensor = 'Tensor'
+
+class InputInfo:
+    Name: str = ''
+    InputType: DataTypes = DataTypes.Integer
+
+class OutcomeInfo:
+    Name: str = ''
+    OutcomeType: DataTypes = DataTypes.Integer
+    
+@attr.s(auto_attribs=True)
+class BasePredictEngineConfig:    
+    # Inputs: list[InputInfo] = None
+    # Outcomes: list[OutcomeInfo] = None
+    Inputs: list
+    Outcomes: list
+
+@attr.s(auto_attribs=True)
+class InferenceContext:
+    ContextId: str = ''
+    StoredMeta: dict = {}
+
+    def toJSON(self):
+        return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
+
+@attr.s(auto_attribs=True)
+class EngineInputs:     
+    InputValues: dict
+    DesiredOutcomes: list    
+
+# Note: these models will be different for every engine type
+###############################################################################################################    
+@attr.s(auto_attribs=True)
+class AppEngineInferenceOptions:    
+    pass
+
+@attr.s(auto_attribs=True)
+class AIEngineConfiguration (BasePredictEngineConfig):    
+    InferenceOptions: AppEngineInferenceOptions = None
+
+@attr.s(auto_attribs=True)
+class AppEngineRequest:    
+    RequestId: str = ''
+    EngineId: str = ''
+    RequestInputFiles: bool = False
+    RequestOutputFiles: bool = False
+    RequestFilesFolderPath: str = False
+    PackagesFolderPath: str = ''
+    PackagesFolderPath: str = ''
+    SourcesFolderPath: str = ''
+    ModelFilesFolderPath: str = ''
+    EngineApiKey: str = ''
+    PredictEndpoint: str = ''
+    Context: InferenceContext = None
+    CallbackQueue: str = ''
+    EngineInputData: EngineInputs = None
+    EngineConfig: AIEngineConfiguration = None
+
+    def toJSON(self):
+        return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
+
+###############################################################################################################
+    
+class UnityPredictEngineResponse:
+    RequestId: str = ''
+    ErrorMessages: str = ''
+    LogMessages: str = ''
+    AdditionalInferenceCosts: float = 0.0
+    EngineOutputs: EngineResults = None
+    Context: InferenceContext = None
+
+    def __init__(self):
+        self.RequestId = ''
+        self.ErrorMessages = ''
+        self.LogMessages = ''
+        self.AdditionalInferenceCosts = 0.0
+        self.EngineOutputs = None
+        self.Context = None
+    
+    def toJSON(self):
+        return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)

unitypredict_engines/Platform.py

@@ -0,0 +1,109 @@
+from abc import ABCMeta, abstractmethod
+from io import BufferedReader, IOBase
+
+class OutcomeValue:
+    Probability = 0.0
+    Value = None
+
+    def __init__(self, value: any = '', probability: float = 0.0):
+        self.Probability = probability
+        self.Value = value
+
+class InferenceContextData:
+    StoredMeta: dict = {}
+
+    def __init__(self):
+        self.StoredMeta = {}
+
+class InferenceRequest:
+    InputValues: dict
+    DesiredOutcomes: list
+    Context: InferenceContextData = None 
+    def __init__(self):
+        self.Context = InferenceContextData()
+        self.InputValues = {}
+        self.DesiredOutcomes = []
+    
+class InferenceResponse:
+    ErrorMessages: str = ''
+    AdditionalInferenceCosts: float = 0.0
+    Context: InferenceContextData = None
+    OutcomeValues: dict = {}
+    Outcomes: dict = {}
+
+    def __init__(self):
+        self.ErrorMessages = ''
+        self.AdditionalInferenceCosts = 0.0
+        self.Context = InferenceContextData()
+        self.OutcomeValues = {}
+        self.Outcomes = {}
+
+class ChainedInferenceRequest:
+    ContextId: str = ''
+    InputValues: dict
+    DesiredOutcomes: list
+
+    def __init__(self):
+        self.ContextId = ''
+        self.InputValues = {}
+        self.DesiredOutcomes = []
+
+    
+class ChainedInferenceResponse:
+    ContextId: str = ''
+    RequestId: str = ''
+    ErrorMessages: str = ''
+    ComputeCost: float = 0.0
+    OutcomeValues: dict = {}
+    Outcomes: dict = {}
+
+    def __init__(self):
+        self.ContextId = ''
+        self.RequestId = ''
+        self.ErrorMessages = ''
+        self.ComputeCost = 0.0
+        self.OutcomeValues = {}
+        self.Outcomes = {}
+
+class FileTransmissionObj:
+    FileName: str = ''
+    FileHandle: IOBase = None
+
+    def __init__(self, fileName, fileHandle):
+        self.FileName = fileName
+        self.FileHandle = fileHandle
+
+class FileReceivedObj:
+    FileName: str = ''
+    LocalFilePath: str = ''
+
+    def __init__(self, fileName, localFilePath):
+        self.FileName = fileName
+        self.LocalFilePath = localFilePath
+
+class IPlatform:
+    __metaclass__ = ABCMeta
+
+    @classmethod
+    def version(self): return "1.0"
+
+    @abstractmethod
+    def getModelsFolderPath(self) -> str: raise NotImplementedError
+
+    @abstractmethod
+    def getModelFile(self, modelFileName: str, mode: str = 'rb') -> IOBase: raise NotImplementedError
+
+    @abstractmethod
+    def getRequestFile(self, modelFileName: str, mode: str = 'rb') -> IOBase: raise NotImplementedError
+
+    @abstractmethod
+    def saveRequestFile(self, modelFileName: str, mode: str = 'wb') -> IOBase: raise NotImplementedError
+
+    @abstractmethod
+    def getLocalTempFolderPath(self) -> str: raise NotImplementedError
+
+    @abstractmethod
+    def logMsg(self, msg: str): raise NotImplementedError
+
+    @abstractmethod
+    def invokeUnityPredictModel(self, modelId: str, request: ChainedInferenceRequest) -> ChainedInferenceResponse: raise NotImplementedError

unitypredict_engines/UnityPredictLocalHost.py

@@ -0,0 +1,460 @@
+import importlib
+from io import BufferedReader, IOBase, StringIO
+
+import json
+import os, sys
+import shutil
+import datetime
+import uuid
+import filecmp
+import attr
+import cattr
+
+import requests
+from .Models import AppEngineRequest, EngineResults, InferenceContext, UnityPredictEngineResponse
+from .Platform import ChainedInferenceRequest, ChainedInferenceResponse, FileReceivedObj, FileTransmissionObj, IPlatform, InferenceRequest,InferenceResponse, InferenceContextData
+
+@attr.s(auto_attribs=True)
+class AppEngineConfig:
+    TempDirPath: str = ''
+    ModelsDirPath: str = ''
+    RequestFilesDirPath: str = ''
+
+    # TEMP_EXEC_DIR: str = os.getcwd()
+    UPT_API_KEY: str = ""
+    # MODEL_DIR: str = os.path.join(os.getcwd(), "models")
+    # REQUEST_DIR: str = os.path.join(os.getcwd(), "requests")
+    SAVE_CONTEXT: bool = True
+
+    def toJSON(self):
+        return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
+
+class UnityPredictHost(IPlatform):
+
+    Initialized = False
+    isConfigInit = False
+    LoadedEngineId = None
+    CurrentRequest: AppEngineRequest = None
+    logMsgs: str = ''
+
+    configFile = os.path.join(os.getcwd(), "config.json")
+
+    appEngineConfig: AppEngineConfig = AppEngineConfig()
+
+    # execTempDir = "execTmp"
+    # execRequestFolder: str = "requests"
+    # execModelFolder: str = "models"
+    # execOutputFolder: str = "outputs"
+
+    def __init__(self) -> None:
+        
+        config_dict : dict = {}
+        if not os.path.exists(self.configFile):
+
+            print ("Config file not detected, creating templated config file: {}".format(self.configFile))
+            
+            # self.appEngineConfig.TEMP_EXEC_DIR = os.getcwd()
+            self.appEngineConfig = AppEngineConfig()
+            self.appEngineConfig.ModelsDirPath = os.path.join(os.getcwd(), "unitypredict_mocktool", "models")
+            self.appEngineConfig.TempDirPath = os.path.join(os.getcwd(), "unitypredict_mocktool", "tmp")
+            self.appEngineConfig.RequestFilesDirPath = os.path.join(os.getcwd(), "unitypredict_mocktool", "requests")
+
+            with open(self.configFile, "w+") as confFile:
+                confFile.write(self.appEngineConfig.toJSON())
+
+        print ("Config file detected, loading data from: {}".format(self.configFile))
+        with open (self.configFile, "r+") as confFile:
+            config_dict = json.load(confFile)
+
+        self.appEngineConfig = cattr.structure(config_dict, AppEngineConfig)
+
+        if not os.path.exists(self.appEngineConfig.ModelsDirPath):
+            os.makedirs(self.appEngineConfig.ModelsDirPath)
+
+        if not os.path.exists(self.appEngineConfig.TempDirPath):
+            os.makedirs(self.appEngineConfig.TempDirPath)
+
+        if not os.path.exists(self.appEngineConfig.RequestFilesDirPath):
+            os.makedirs(self.appEngineConfig.RequestFilesDirPath)
+
+        self.CurrentRequest = AppEngineRequest()
+
+        # self.workingDir = os.path.join(self.appEngineConfig.TEMP_EXEC_DIR, self.execTempDir)
+        self.CurrentRequest.EngineApiKey = self.appEngineConfig.UPT_API_KEY
+
+
+        # self.CurrentRequest.ModelFilesFolderPath = os.path.join(self.workingDir, self.execModelFolder)
+        # self.CurrentRequest.RequestFilesFolderPath = os.path.join(self.workingDir, self.execRequestFolder)
+        
+            
+        self.isConfigInit = True
+
+        return None
+    
+    def isConfigInitialized(self) -> bool:
+
+        return self.isConfigInit
+    
+    def isPlatformInitialized(self) -> bool:
+
+        return self.Initialized
+    
+    
+    def getModelsFolderPath(self) -> str:
+        return self.appEngineConfig.ModelsDirPath
+    
+    def getModelFile(self, modelFileName: str, mode: str = 'rb') -> IOBase:
+        absFilePath = os.path.join(self.getModelsFolderPath(), modelFileName)
+        fileHandler = open(absFilePath, mode)
+
+        return fileHandler
+    
+
+    def getLocalTempFolderPath(self) -> str: 
+        return self.appEngineConfig.TempDirPath
+    
+    def getRequestFolderPath(self) -> str:
+        return self.appEngineConfig.RequestFilesDirPath
+
+        
+    def getRequestFile(self, requestFileName: str, mode: str = 'rb') -> IOBase: 
+        absFilePath = os.path.join(self.getRequestFolderPath(), requestFileName)
+        fileHandler = open(absFilePath, mode)
+
+        return fileHandler
+    
+    def saveRequestFile(self, requestFileName: str, mode: str = 'wb') -> IOBase: 
+        absFilePath = os.path.join(self.getRequestFolderPath(), requestFileName)
+        fileHandler = open(absFilePath, mode)
+
+        return fileHandler
+    
+    
+    def logMsg(self, msg: str):
+        print("\n{}\n".format(msg))
+        self.logMsgs += "\n{}\n".format(msg)
+
+    def errorMsg(self, msg: str):
+        self.errorMsgs += "\n{}\n".format(msg)
+
+
+    # def syncDirectories(self, source: str, destination: str, create_dest_if_not_present: bool = False):
+        
+    #     if not os.path.exists(source) or not os.path.isdir(source):
+    #         print(f"Source directory '{source}' does not exist or is not a directory.")
+    #         return
+
+    #     if create_dest_if_not_present:
+    #         if not os.path.exists(destination):
+    #             os.makedirs(destination)
+    #     else:
+    #         if not os.path.exists(destination) or not os.path.isdir(source):
+    #             print(f"Destination directory '{destination}' does not exist or is not a directory.")
+    #             return
+
+    #     # Copy or update files from source to destination
+    #     for src_dir, _, files in os.walk(source):
+    #         dst_dir = src_dir.replace(source, destination, 1)
+    #         if not os.path.exists(dst_dir):
+    #             os.makedirs(dst_dir)
+
+    #         for file in files:
+    #             src_file = os.path.join(src_dir, file)
+    #             dst_file = os.path.join(dst_dir, file)
+
+    #             if not os.path.exists(dst_file) or not filecmp.cmp(src_file, dst_file, shallow=False):
+    #                 shutil.copy2(src_file, dst_file)  # Preserve metadata with copy2
+    #                 print(f"Copied: {src_file} to {dst_file}")
+    #             else:
+    #                 print(f"Skipped: {src_file} is already up to date.")
+
+    #     # Remove files and directories from destination that are not in source
+    #     for dst_dir, _, files in os.walk(destination, topdown=False):
+    #         src_dir = dst_dir.replace(destination, source, 1)
+
+    #         if not os.path.exists(src_dir):
+    #             shutil.rmtree(dst_dir)
+    #             print(f"Removed directory: {dst_dir}")
+    #         else:
+    #             for file in files:
+    #                 dst_file = os.path.join(dst_dir, file)
+    #                 src_file = os.path.join(src_dir, file)
+
+    #                 if not os.path.exists(src_file):
+    #                     os.remove(dst_file)
+    #                     print(f"Removed file: {dst_file}")
+
+    # def createPlatform(self, request: AppEngineRequest) -> bool:
+    #     if not self.isConfigInit:
+    #         return False
+        
+    #     # Creating output folder based on RequestID
+    #     if (request.RequestId == ""):
+
+    #         self.errorMsg("Please provide a proper request id\n")
+
+    #         return False
+         
+    #     # Create the folders
+    #     if not os.path.exists(self.workingDir):
+    #         os.mkdir(self.workingDir)
+        
+    #     if not os.path.exists(self.CurrentRequest.ModelFilesFolderPath):
+    #         os.mkdir(self.CurrentRequest.ModelFilesFolderPath)
+
+    #     # Create request folder having the name of the current Timestamp
+    #     currentExecTime = datetime.datetime.now()
+    #     currentExecTime = currentExecTime.strftime("%d-%m-%YT%H-%M-%S")
+        
+    #     self.execRequestFolder = "{}_{}__{}".format(self.execRequestFolder, currentExecTime, request.RequestId)
+    #     self.CurrentRequest.RequestFilesFolderPath = os.path.join(self.workingDir, self.execRequestFolder)
+
+    #     if not os.path.exists(self.CurrentRequest.RequestFilesFolderPath):
+    #         os.mkdir(self.CurrentRequest.RequestFilesFolderPath)
+        
+        
+    #     # Create output folder based on the request Id
+    #     self.execOutputFolder = "{}_{}__{}".format(self.execOutputFolder, currentExecTime, request.RequestId)
+    #     self.execOutputFolder = os.path.join(self.workingDir, self.execOutputFolder)
+    #     if not os.path.exists(self.execOutputFolder):
+    #         os.mkdir(self.execOutputFolder)
+
+
+    #     # TODO: Copy user configured folder contents to respective exec folders
+    #     # Sync Request Files
+    #     self.syncDirectories(self.appEngineConfig.REQUEST_DIR, self.CurrentRequest.RequestFilesFolderPath)
+    #     # Sync Model Files
+    #     self.syncDirectories(self.appEngineConfig.MODEL_DIR, self.CurrentRequest.ModelFilesFolderPath)
+
+    #     self.Initialized = True
+
+    #     return True
+    
+    def run_engine(self, request: AppEngineRequest) -> UnityPredictEngineResponse:
+
+        self.logMsgs: str = ''
+        self.MaxlogMsgBuffer: int = 3000
+        self.NegMaxlogMsgBuffer: int = -1 * self.MaxlogMsgBuffer
+
+        self.errorMsgs: str = ''
+        self.MaxErrorMsgsBuffer: int = 3000
+        self.NegMaxErrorMsgsBuffer: int = -1 * self.MaxErrorMsgsBuffer
+        
+        toreturn: UnityPredictEngineResponse = UnityPredictEngineResponse()
+        try:  
+
+            # # Create the platform for execution
+            # # 1) Prepare temp folders on local directories for A) Request Files B) Model Files C) Temp Files
+            # # 2) Put the files into the right folders 
+            # if not self.createPlatform(request=request):
+
+            #     self.errorMsg("Unable to create the platform")
+            #     toreturn.ErrorMessages = self.errorMsgs[self.NegMaxErrorMsgsBuffer:] # limit length of the logs
+            #     toreturn.LogMessages = self.logMsgs[self.NegMaxlogMsgBuffer:] # limit length of the logs
+
+            #     return toreturn
+            
+            
+            # 3) Store/Restore Context (probably using some local json file) if requested by user
+            # Initialize context
+
+            if (self.appEngineConfig.SAVE_CONTEXT):
+                
+                contextJson = os.path.join(self.getLocalTempFolderPath(), "context.json")
+                
+                context = {}
+                if os.path.exists(contextJson):
+                    with open(contextJson, "r+") as ctxtf:
+                        context = json.load(ctxtf) 
+
+                    request.Context = InferenceContext(**context)
+
+            # 4) Convert the AppEngineRequest to the InferenceRequest that the model needs
+
+            inferReq: InferenceRequest = InferenceRequest()
+            inferReq.InputValues = request.EngineInputData.InputValues
+            inferReq.DesiredOutcomes = request.EngineInputData.DesiredOutcomes
+
+            inferReq.Context = InferenceContextData()
+
+            if (request.Context != None):
+                inferReq.Context.StoredMeta = request.Context.StoredMeta
+            else:
+                inferReq.Context.StoredMeta = {}
+            
+
+            # 5) Run EntryPoint.py
+            entryPoint = importlib.import_module("EntryPoint")
+            inferResp: InferenceResponse = entryPoint.run_local_engine(inferReq, self)
+
+            # 6) Copy InferenceResponse to UnityPredictEngineResponse
+
+            toreturn.AdditionalInferenceCosts = inferResp.AdditionalInferenceCosts
+            toreturn.EngineOutputs = EngineResults()
+            
+            if (inferResp.Outcomes != None):
+                toreturn.EngineOutputs.Outcomes = inferResp.Outcomes
+            else:
+                toreturn.EngineOutputs.Outcomes = {}
+
+            if (inferResp.OutcomeValues != None):
+                toreturn.EngineOutputs.OutcomeValues = inferResp.OutcomeValues
+            else:
+                toreturn.EngineOutputs.OutcomeValues = {}
+
+
+            toreturn.EngineOutputs.OutcomeValues = inferResp.OutcomeValues
+            toreturn.ErrorMessages = inferResp.ErrorMessages
+
+            if (self.appEngineConfig.SAVE_CONTEXT):
+            
+                toreturn.Context = InferenceContext(ContextId="")
+                if (request.Context  != None):
+                    toreturn.Context.ContextId = request.Context.ContextId 
+                if (inferResp.Context == None or inferResp.Context.StoredMeta == None or inferResp.Context.StoredMeta == {}):
+                    
+                    if (request.Context  != None):
+                        toreturn.Context.StoredMeta = inferReq.Context.StoredMeta
+                    else:
+                        toreturn.Context.StoredMeta = {}
+                    
+                else:    
+                    toreturn.Context.StoredMeta = inferResp.Context.StoredMeta
+
+                if toreturn.Context.ContextId == "":
+                    toreturn.Context.ContextId = str(uuid.uuid4())
+
+
+                with open(contextJson, "w+") as ctxtf:
+                    ctxtf.write(toreturn.Context.toJSON())
+
+
+            toreturn.LogMessages = self.logMsgs[self.NegMaxlogMsgBuffer:] # limit length of the logs
+            
+        except Exception as e:
+
+            print ("Error occured: {}".format(str(e)))
+            self.errorMsg(str(e))
+            toreturn.ErrorMessages += self.errorMsgs[self.NegMaxErrorMsgsBuffer:] # limit length of the logs
+            toreturn.LogMessages = self.logMsgs[self.NegMaxlogMsgBuffer:] # limit length of the logs
+
+        return toreturn
+        
+
+    def invokeUnityPredictModel(self, modelId: str, request: ChainedInferenceRequest) -> ChainedInferenceResponse:
+        results = ChainedInferenceResponse()
+
+        apiKey = self.CurrentRequest.EngineApiKey
+        apiBaseUrl = "https://api.prod.unitypredict.com/api/predict"
+
+        needFileUpload: bool = False
+
+        ##### 
+        # The request can contain file objects so we need to change those to file names before sending out
+        #####
+        # first get a list of file that we'll need to upload later & update the POST obj
+        filesToUpload = {}
+        for xvarName in request.InputValues:
+            if isinstance(request.InputValues.get(xvarName), FileTransmissionObj):
+                needFileUpload = True
+                break
+
+        finalResponseJson: any = ''
+
+        response: requests.Response = None
+        if not needFileUpload:
+            # serialize the POST obj
+            jsonBody = json.dumps(request, default=vars)
+
+            # there are no files to upload so just post normally
+            response = requests.post(url = "{}/{}".format(apiBaseUrl, modelId), data=jsonBody, headers={"Authorization": "Bearer APIKEY@{}".format(apiKey)})
+
+            if response.status_code != 200:
+                results.ErrorMessages = 'Error from server: {}'.format(response.status_code)
+                return results
+            
+            finalResponseJson = response.json()
+        else:
+            # we need to initialize first
+            response = requests.post(url = "{}/initialize/{}".format(apiBaseUrl, modelId), data="", headers={"Authorization": "Bearer APIKEY@{}".format(apiKey)})
+
+            requestId: str = response.json().get('requestId')
+
+            if response.status_code != 200:
+                results.ErrorMessages = 'Error from server: {}'.format(response.status_code)
+                return results
+            
+            # upload the files
+            for xvarName in request.InputValues: 
+                if isinstance(request.InputValues.get(xvarName), FileTransmissionObj):
+                    fileToUpload: FileTransmissionObj = request.InputValues.get(xvarName)
+                    response = requests.get(url = "{}/upload/{}/{}".format(apiBaseUrl, requestId, fileToUpload.FileName), headers={"Authorization": "Bearer APIKEY@{}".format(apiKey)})
+                    uploadLink = response.json().get('uploadLink')
+                    fileName = response.json().get('fileName')
+                    request.InputValues[xvarName] = fileName # make sure that only the filename is in the request that we are going to POST
+                    requests.put(url = uploadLink, data=fileToUpload.FileHandle)
+            
+            jsonBody = json.dumps(request, default=vars)
+            
+            response = requests.post(url = "{}/{}/{}".format(apiBaseUrl, modelId, requestId), data=jsonBody, headers={"Authorization": "Bearer APIKEY@{}".format(apiKey)})
+
+            finalResponseJson = response.json()
+
+        
+        print(finalResponseJson)
+
+        while (finalResponseJson.get('status') == 'Processing'):
+            statusUrl: str = finalResponseJson.get('statusUrl')
+
+            response = requests.get(url = statusUrl, headers={"Authorization": "Bearer APIKEY@{}".format(apiKey)})
+            finalResponseJson = response.json()
+
+
+        finalResponseRequestId: str = finalResponseJson.get('requestId')
+
+        tempOutputFolder: str = os.path.join(self.getLocalTempFolderPath(), "chainedResults", finalResponseRequestId)
+        if not os.path.exists(tempOutputFolder):
+            os.makedirs(tempOutputFolder)
+
+        outcomeValues = finalResponseJson.get('outcomeValues')
+        for outputVarName in outcomeValues: 
+            outcome: dict = outcomeValues.get(outputVarName)
+            if outcome.get('dataType') == 'File':
+                fileName = outcome.get('value')
+
+                tempFilePath = os.path.join(tempOutputFolder, fileName)
+                response = requests.get(url = "{}/download/{}/{}".format(apiBaseUrl, finalResponseRequestId, fileName), headers={"Authorization": "Bearer APIKEY@{}".format(apiKey)})
+                with open(tempFilePath, 'wb') as f:
+                    f.write(response.content)
+
+                fileReceived: FileReceivedObj = FileReceivedObj(fileName, tempFilePath)
+                outcome['value'] = fileReceived
+
+        outcomes = finalResponseJson.get('outcomes')
+        for outputVarName in outcomes: 
+            outcome: list = outcomes.get(outputVarName)
+            for outcomeItem in outcome:
+                if outcomeItem.get('dataType') == 'File':
+                    fileName = outcomeItem.get('value')
+
+                    tempFilePath = os.path.join(tempOutputFolder, fileName)
+                    response = requests.get(url = "{}/download/{}/{}".format(apiBaseUrl, finalResponseRequestId, fileName), headers={"Authorization": "Bearer APIKEY@{}".format(apiKey)})
+                    with open(tempFilePath, 'wb') as f:
+                        f.write(response.content)
+
+                    fileReceived: FileReceivedObj = FileReceivedObj(fileName, tempFilePath)
+                    outcomeItem['value'] = fileReceived
+
+
+        try:
+            results.ComputeCost = finalResponseJson.get('computeCost')
+            results.OutcomeValues = outcomeValues
+            results.Outcomes = outcomes
+            results.RequestId = finalResponseRequestId
+            results.ContextId = finalResponseJson.get('contextId')
+            results.ErrorMessages = finalResponseJson.get('errorMessages')
+
+        except Exception as e:
+            print(e)
+
+        return results

unitypredict_engines/__init__.py

@@ -0,0 +1 @@
+from .UnityPredictLocalHost import UnityPredictHost

unitypredict_engines/scripts.py

@@ -0,0 +1,5 @@
+import sys
+
+def main():
+   cmd = sys.argv[1:]
+   print(f'Command = {cmd}')

unitypredict_engines-0.0.1.dist-info/METADATA

@@ -0,0 +1,194 @@
+Metadata-Version: 2.1
+Name: unitypredict-engines
+Version: 0.0.1
+Description-Content-Type: text/markdown
+
+# UnityPredict Local App Engine Creator
+
+## Introduction
+
+The `UnityPredict` python sdk is designed to help accelerate the testing and debugging of **App Engines** for deployment on the `UnityPredict` platform.
+
+On `UnityPredict`, **"Engines"** are the underlying compute framework that is executed, at scale, to perform inference or run business logic. In contrast, **"Models"** define the interface for these Engines. **Every Engine must be connected to a "Model"** because the Model serves as the interface that defines how `UnityPredict` communicates with the Engine. The Model specifies variable names and data types for inputs and outputs. Additionally, `UnityPredict` uses the Model definition to auto-generate APIs and user interfaces.
+
+**"App Engines"** are specialized extensions of `UnityPredict` Engines that allow developers to write custom Python code, which the platform will execute at scale. These custom-defined Engines offer developers the flexibility needed to create complex applications. Within an App Engine, developers can access various platform features through code. For instance, **App Engine code can easily invoke other models (aka. chaining) or define cost calculations**. App Engines also enable developers to choose specific hardware types for running their code.
+
+This guide focuses on the local development and testing of custom App Engine code.
+
+For a full guide on how to use App Engine(s) on UnityPredict, please visit our complete help documentation here [UnityPredict Docs](https://console.unitypredict.com).
+
+## Installation
+* You can use pip to install the ```unitypredict``` library.
+```bash
+pip install unitypredict
+```
+
+## Usage
+
+### EntryPoint.py
+
+#### What is `EntryPoint.py`
+
+`EntryPoint.py` is the script created by the **user** to provide the platform a well-defined function that can be invoked as the **starting point** for the **inference code**. It also acts as a gateway to access the **"platform"** object containing various features provided by UnityPredict
+
+### Create an example `EntryPoint.py`
+
+Create a custom entrypoint of your App Engine under the file **`EntryPoint.py`** containing the inference logic.
+
+**NOTE:** The name of the file should be **`EntryPoint.py`**. If not followed, during the actual deployment on `UnityPredict` repository, the created file might not get invoked due to anincorrect name.
+
+Given below is an example of a simple **`EntryPoint.py`**
+
+
+```python
+from unitypredict.Platform import IPlatform, InferenceRequest, InferenceResponse, OutcomeValue, InferenceContextData
+import datetime
+
+
+
+def run_engine(request: InferenceRequest, platform: IPlatform) -> InferenceResponse:
+
+    
+
+    platform.logMsg("Running User Code...")
+    response = InferenceResponse()
+
+    try:
+        prompt = request.InputValues['InputMessage']
+
+        currentExecTime = datetime.datetime.now()
+        currentExecTime = currentExecTime.strftime("%d-%m-%YT%H-%M-%S")
+        resp_message = "Echo message: {} Time:: {}".format(prompt, currentExecTime)   
+        
+        response.Outcomes['OutputMessage'] = [OutcomeValue(value=resp_message, probability=1.0)]
+
+    except Exception as e:
+        response.ErrorMessages = "Entrypoint Exception Occured: {}".format(str(e))
+
+    print("Finished Running User Code...")
+    return response
+
+```
+
+### Running the `EntryPoint.py`
+
+In order to run the `EntryPoint.py` locally, add the following `main` section to the file itself.
+
+```python
+#### For Local testing ###
+
+if __name__ == "__main__":
+
+    from unitypredict import UnityPredictHost
+    
+    # Initialize the UnityPredict Platform
+    platform = UnityPredictHost()
+
+    testRequest = InferenceRequest()
+    testRequest.InputValues = {}
+    testRequest.InputValues["InputMessage"] = "Hi, this is an echo message"
+    results: InferenceResponse = run_engine(testRequest, platform)
+
+    # Print Outputs
+    if (results.Outcomes != None):
+        for outcomKeys, outcomeValues in results.Outcomes.items():
+            print ("\n\nOutcome Key: {}".format(outcomKeys))
+            for values in outcomeValues:
+                infVal: OutcomeValue = values
+                print ("Outcome Value: \n{}\n\n".format(infVal.Value))
+                print ("Outcome Probability: \n{}\n\n".format(infVal.Probability))
+    
+    # Print Error Messages (if any)
+    print ("Error Messages: {}".format(results.ErrorMessages))
+
+```
+Now run the `EntryPoint.py`
+
+```bash
+python EntryPoint.py
+```
+
+### Output
+
+The output should be the message added as the `InputMessage` in the main, appended with the timestamp of the execution.
+
+```bash
+Config file detected, loading data from: D:\Documents\SelfProjects\UPTAzure\unitypredict-sdks\mainFolder\config.json
+
+Running User Code...
+
+Finished Running User Code...
+
+
+Outcome Key: OutputMessage
+Outcome Value:
+Echo message: Hi, this is an echo message Time:: 18-08-2024T18-56-33
+
+
+Outcome Probability:
+1.0
+```
+
+
+While running the script for the **first time**, you may also encounter a log message as follows.
+
+```bash
+Config file not detected, creating templated config file: {project-current-folder}\config.json
+```
+This marks the auto-creation of the config file template `config.json`, along with the tree-structure following the templated config of the project which is the **mock building block** for the APIs of `UnityPredict` used under `EntryPoint.py`.
+
+
+
+### Config File and the project tree structure
+
+The templated `config.json` looks like this:
+```json
+{
+    "ModelsDirPath": "{userPWD}/unitypredict_mocktool/models",
+    "RequestFilesDirPath": "{userPWD}/unitypredict_mocktool/requests",
+    "SAVE_CONTEXT": true,
+    "TempDirPath": "{userPWD}/unitypredict_mocktool/tmp",
+    "UPT_API_KEY": ""
+}
+```
+
+And the tree structure of the generated directory will be:
+```plaintext
+{userPWD}/
+├── unitypredict_mocktool/
+|    ├── models/
+|    ├── requests/
+|    └── tmp/
+└── EntryPoint.py
+└── config.json
+```
+
+Details of the JSON settings:
+
+* **ModelsDirPath**: Local model files/binaries to be uploaded to AppEngine for using during the execution can be added under the specified **ModelsDirPath**
+
+* **RequestFilesDirPath**: Files or Folders to be uploaded to AppEngine for using during the execution can be added under the specified **RequestFilesDirPath**
+
+* **SAVE_CONTEXT**: Retains context across multiple requests. Disable it using ```"SAVE_CONTEXT" : false```
+
+* **UPT_API_KEY**: API Key token generated from the UnityPredict profile of the user.
+
+* **TempDirPath**: Temporary directory which can be used for writing or reading extra files or folders depending on the requirements of the App Engine
+
+
+
+
+## License
+Copyright 2013 Mir Ikram Uddin
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

unitypredict_engines-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+unitypredict_engines/Models.py,sha256=hwndzMFoFKHmkRpcxPDcjdV9WV1PHAPvzq6TCYLyFxw,3153
+unitypredict_engines/Platform.py,sha256=QIImp7Xilhn7YvQsoGniO7N-mn05OLatkXWhuWc05y0,3052
+unitypredict_engines/UnityPredictLocalHost.py,sha256=Ta1_c8IXPe2KTS6s7cw9qwO832Zx3Mn8XNO1n6-qhaY,19580
+unitypredict_engines/__init__.py,sha256=ZVud1XT9QzEZQhcxtFU2I4NVAhof7K5jCFM3fd9fC3M,51
+unitypredict_engines/scripts.py,sha256=LcHSImPxZVucaPasc5ZOySS1GlrU-FOLg_uR561aF7o,78
+unitypredict_engines-0.0.1.dist-info/METADATA,sha256=ko0zzwA0XFnPR6GX8t_zOvGYMvFxGvq82PWt3pdUGXM,7595
+unitypredict_engines-0.0.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+unitypredict_engines-0.0.1.dist-info/entry_points.txt,sha256=JlCMnQrC6MFXk3OZWL9FG01fjSkMzlkqtZaz5njuqHg,75
+unitypredict_engines-0.0.1.dist-info/top_level.txt,sha256=u73Hru2uPFzda_gdgAAwcaVTBYZKBjDcWkhgTt209TA,21
+unitypredict_engines-0.0.1.dist-info/RECORD,,

unitypredict_engines-0.0.1.dist-info/WHEEL

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

unitypredict_engines-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+unitypredict-engines = unitypredict_engines.scripts:main

unitypredict_engines-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+unitypredict_engines