unitypredict 0.1.17__tar.gz

unitypredict-0.1.17/PKG-INFO

@@ -0,0 +1,220 @@
+Metadata-Version: 2.1
+Name: unitypredict
+Version: 0.1.17
+Description-Content-Type: text/markdown
+
+# UnityPredict Local App Engine Creator
+
+## Introduction
+
+This library allows you to create App Engines in your local system and finetune the engines before updating it to the [ModelCentral](https://modelcentral.ai) repositories.
+
+## Installation
+* You can use pip to install the ```UnityPredict``` library.
+```bash
+pip install UnityPredict
+```
+
+## Usage
+Use the following snippet to initialize the environment.
+
+
+### main.py
+
+```python
+
+from UnityPredict import UnityPredictHost, Models
+import sys
+import uuid
+
+import time
+
+import os
+
+
+
+if __name__ == "__main__":        
+    platformInit = UnityPredictHost()
+
+    configStat = platformInit.isConfigInitialized()
+
+    if not configStat:
+        print ("Config Initialization Unsuccessful!!")
+        sys.exit(0)
+    
+    
+    print ("Config Initialization Successful!!")
+
+```
+
+* This is the snippet to initialize the AppEngine environment.
+* Run script using the following command:
+
+```bash
+python main.py
+```
+
+* If this script is run for the **first time**. The following Output will be shown
+
+```bash
+
+Config file not detected, creating templated config file: YourScriptPath/config.json
+Config Initialization Unsuccessful!!
+
+```
+* A templated config file would be generated on the same directory as that of your main script.
+
+```json
+{
+    "MODEL_DIR": "YourScriptPath/models",
+    "REQUEST_DIR": "YourScriptPath/requests",
+    "SAVE_CONTEXT": true,
+    "TEMP_EXEC_DIR": "YourScriptPath",
+    "UPT_API_KEY": ""
+}
+
+```
+
+* Edit the JSON as per your requirements. The various keys represent:
+
+    * **TEMP_EXEC_DIR**: Directory on which you wan the AppEngine to run
+    
+    * **REQUEST_DIR**: Files or Folders to be uploaded to AppEngine for using during the execution can be added under the specified **REQUEST_DIR**
+
+    * **MODEL_DIR**: Local model files/binaries to be uploaded to AppEngine for using during the execution can be added under the specified **MODEL_DIR**
+
+    * **SAVE_CONTEXT**: Retains context across multiple requests. Disable it using ```"SAVE_CONTEXT" : false```
+
+    * **UPT_API_KEY**: API Key token generated from the ModelCentral profile of the user.
+
+* Once configured, run the following script once again to get:
+
+```bash
+Config Initialization Successful!!
+```
+
+### EntryPoint.py
+
+* In order to run your custom AppEngine, it is necessary to create a file named ```EntryPoint.py``` which is going to contain the inference logic.
+
+This is an Example snippet of the `EntryPoint.py`:
+```python
+import json
+from UnityPredict.Platform import IPlatform, InferenceRequest, InferenceResponse, OutcomeValue, InferenceContextData
+from typing import List, Dict, Optional
+from collections import deque
+import sys
+import datetime
+
+
+
+def run_local_engine(request: InferenceRequest, platform: IPlatform) -> InferenceResponse:
+
+    
+
+    platform.logMsg("Running User Code...")
+    response = InferenceResponse()
+    
+    context: Dict[str, str] = {}
+
+    try:
+        prompt = request.InputValues['InputMessage']
+
+        
+        # Saved context across requests
+        # Use this variable to save new context in the dict format
+        # request.Context.StoredMeta is of the format: Dict[str, str]
+        context = request.Context.StoredMeta
+
+        currentExecTime = datetime.datetime.now()
+        currentExecTime = currentExecTime.strftime("%d-%m-%YT%H-%M-%S")
+        resp_message = "Echo message: {} Time:: {}".format(prompt, currentExecTime)
+
+        
+        # platform.getRequestFile: Fetch Files specified under the "REQUEST_DIR" in config
+        with platform.getRequestFile("myDetails.txt", "r") as reqFile:
+
+            resp_message += "\n{}".format("\n".join(reqFile.readlines()))
+
+        
+        # Fill context according to your needs
+        context[currentExecTime] = resp_message    
+        
+        
+        # platform.saveRequestFile: Creates any file type Outputs
+        # These files would be present under TEMP_EXEC_DIR/execTmp/outputs_<RequestLaunchTimeStamp>__<RequestId>
+        # TEMP_EXEC_DIR: Configured under the config.json
+        # execTmp: Creates enviroment for the AppEngine under the specified TEMP_EXEC_DIR
+        with platform.saveRequestFile("final_resp_{}.txt".format(currentExecTime), "w+") as outFile:
+
+            outFile.write(resp_message)
+
+        
+        cost = len(prompt)/1000 * 0.03 + len(resp_message)/1000 * 0.06
+        response.AdditionalInferenceCosts = cost
+        response.Outcomes['OutputMessage'] = [OutcomeValue(value=resp_message, probability=1.0)]
+        
+        # Set the updated context back to the response
+        response.Context.StoredMeta = context
+    except Exception as e:
+        response.ErrorMessages = "Entrypoint Exception Occured: {}".format(str(e))
+
+    print("Finished Running User Code...")
+    return response
+
+
+```
+
+* Some APIs for using the AppEngine environment
+    * **request.Context.StoredMeta**:
+        * Saved context across requests
+        * Use this variable to save new context in the dict format
+        * request.Context.StoredMeta is of the format: Dict[str, str]
+
+    * **platform.getRequestFile**: 
+        * Fetch Files specified under the "**REQUEST_DIR**" in config
+
+    * **platform.saveRequestFile**: 
+        * Creates any file type Outputs
+        * These files would be present under **TEMP_EXEC_DIR/execTmp/*outputs_RequestLaunchTimeStamp__RequestId***
+        * **TEMP_EXEC_DIR**: Configured under the config.json
+        * execTmp: Creates enviroment for the AppEngine under the specified TEMP_EXEC_DIR
+
+
+* Go back to the `main.py` and add the following command to run your `EntryPoint.py`
+
+```python
+if __name__ == "__main__":        
+    
+    # Previous Snippet for initialization
+    platformInit = UnityPredictHost()
+
+    configStat = platformInit.isConfigInitialized()
+
+    if not configStat:
+        print ("Config Initialization Unsuccessful!!")
+        sys.exit(0)
+    
+    
+    print ("Config Initialization Successful!!")
+
+    #### New Snippet to run EntryPoint.py via the AppEngine
+
+    request = Models.AppEngineRequest(RequestId=str(uuid.uuid4()))
+    request.EngineInputData = Models.EngineInputs(InputValues={"InputMessage": "Hi, this is the message to be echoed"}, DesiredOutcomes=[])
+    
+    response : Models.UnityPredictEngineResponse = platformInit.run_engine(request=request)
+
+    # Print Outputs
+    if (response.EngineOutputs != None):
+        print ("Output: {}".format(response.EngineOutputs.toJSON()))
+    
+    # Print Error Messages (if any)
+    print ("Error Messages: {}".format(response.ErrorMessages))
+    
+```
+
+
+## Contributing
+
+## License

unitypredict-0.1.17/README.md

@@ -0,0 +1,215 @@
+# UnityPredict Local App Engine Creator
+
+## Introduction
+
+This library allows you to create App Engines in your local system and finetune the engines before updating it to the [ModelCentral](https://modelcentral.ai) repositories.
+
+## Installation
+* You can use pip to install the ```UnityPredict``` library.
+```bash
+pip install UnityPredict
+```
+
+## Usage
+Use the following snippet to initialize the environment.
+
+
+### main.py
+
+```python
+
+from UnityPredict import UnityPredictHost, Models
+import sys
+import uuid
+
+import time
+
+import os
+
+
+
+if __name__ == "__main__":        
+    platformInit = UnityPredictHost()
+
+    configStat = platformInit.isConfigInitialized()
+
+    if not configStat:
+        print ("Config Initialization Unsuccessful!!")
+        sys.exit(0)
+    
+    
+    print ("Config Initialization Successful!!")
+
+```
+
+* This is the snippet to initialize the AppEngine environment.
+* Run script using the following command:
+
+```bash
+python main.py
+```
+
+* If this script is run for the **first time**. The following Output will be shown
+
+```bash
+
+Config file not detected, creating templated config file: YourScriptPath/config.json
+Config Initialization Unsuccessful!!
+
+```
+* A templated config file would be generated on the same directory as that of your main script.
+
+```json
+{
+    "MODEL_DIR": "YourScriptPath/models",
+    "REQUEST_DIR": "YourScriptPath/requests",
+    "SAVE_CONTEXT": true,
+    "TEMP_EXEC_DIR": "YourScriptPath",
+    "UPT_API_KEY": ""
+}
+
+```
+
+* Edit the JSON as per your requirements. The various keys represent:
+
+    * **TEMP_EXEC_DIR**: Directory on which you wan the AppEngine to run
+    
+    * **REQUEST_DIR**: Files or Folders to be uploaded to AppEngine for using during the execution can be added under the specified **REQUEST_DIR**
+
+    * **MODEL_DIR**: Local model files/binaries to be uploaded to AppEngine for using during the execution can be added under the specified **MODEL_DIR**
+
+    * **SAVE_CONTEXT**: Retains context across multiple requests. Disable it using ```"SAVE_CONTEXT" : false```
+
+    * **UPT_API_KEY**: API Key token generated from the ModelCentral profile of the user.
+
+* Once configured, run the following script once again to get:
+
+```bash
+Config Initialization Successful!!
+```
+
+### EntryPoint.py
+
+* In order to run your custom AppEngine, it is necessary to create a file named ```EntryPoint.py``` which is going to contain the inference logic.
+
+This is an Example snippet of the `EntryPoint.py`:
+```python
+import json
+from UnityPredict.Platform import IPlatform, InferenceRequest, InferenceResponse, OutcomeValue, InferenceContextData
+from typing import List, Dict, Optional
+from collections import deque
+import sys
+import datetime
+
+
+
+def run_local_engine(request: InferenceRequest, platform: IPlatform) -> InferenceResponse:
+
+    
+
+    platform.logMsg("Running User Code...")
+    response = InferenceResponse()
+    
+    context: Dict[str, str] = {}
+
+    try:
+        prompt = request.InputValues['InputMessage']
+
+        
+        # Saved context across requests
+        # Use this variable to save new context in the dict format
+        # request.Context.StoredMeta is of the format: Dict[str, str]
+        context = request.Context.StoredMeta
+
+        currentExecTime = datetime.datetime.now()
+        currentExecTime = currentExecTime.strftime("%d-%m-%YT%H-%M-%S")
+        resp_message = "Echo message: {} Time:: {}".format(prompt, currentExecTime)
+
+        
+        # platform.getRequestFile: Fetch Files specified under the "REQUEST_DIR" in config
+        with platform.getRequestFile("myDetails.txt", "r") as reqFile:
+
+            resp_message += "\n{}".format("\n".join(reqFile.readlines()))
+
+        
+        # Fill context according to your needs
+        context[currentExecTime] = resp_message    
+        
+        
+        # platform.saveRequestFile: Creates any file type Outputs
+        # These files would be present under TEMP_EXEC_DIR/execTmp/outputs_<RequestLaunchTimeStamp>__<RequestId>
+        # TEMP_EXEC_DIR: Configured under the config.json
+        # execTmp: Creates enviroment for the AppEngine under the specified TEMP_EXEC_DIR
+        with platform.saveRequestFile("final_resp_{}.txt".format(currentExecTime), "w+") as outFile:
+
+            outFile.write(resp_message)
+
+        
+        cost = len(prompt)/1000 * 0.03 + len(resp_message)/1000 * 0.06
+        response.AdditionalInferenceCosts = cost
+        response.Outcomes['OutputMessage'] = [OutcomeValue(value=resp_message, probability=1.0)]
+        
+        # Set the updated context back to the response
+        response.Context.StoredMeta = context
+    except Exception as e:
+        response.ErrorMessages = "Entrypoint Exception Occured: {}".format(str(e))
+
+    print("Finished Running User Code...")
+    return response
+
+
+```
+
+* Some APIs for using the AppEngine environment
+    * **request.Context.StoredMeta**:
+        * Saved context across requests
+        * Use this variable to save new context in the dict format
+        * request.Context.StoredMeta is of the format: Dict[str, str]
+
+    * **platform.getRequestFile**: 
+        * Fetch Files specified under the "**REQUEST_DIR**" in config
+
+    * **platform.saveRequestFile**: 
+        * Creates any file type Outputs
+        * These files would be present under **TEMP_EXEC_DIR/execTmp/*outputs_RequestLaunchTimeStamp__RequestId***
+        * **TEMP_EXEC_DIR**: Configured under the config.json
+        * execTmp: Creates enviroment for the AppEngine under the specified TEMP_EXEC_DIR
+
+
+* Go back to the `main.py` and add the following command to run your `EntryPoint.py`
+
+```python
+if __name__ == "__main__":        
+    
+    # Previous Snippet for initialization
+    platformInit = UnityPredictHost()
+
+    configStat = platformInit.isConfigInitialized()
+
+    if not configStat:
+        print ("Config Initialization Unsuccessful!!")
+        sys.exit(0)
+    
+    
+    print ("Config Initialization Successful!!")
+
+    #### New Snippet to run EntryPoint.py via the AppEngine
+
+    request = Models.AppEngineRequest(RequestId=str(uuid.uuid4()))
+    request.EngineInputData = Models.EngineInputs(InputValues={"InputMessage": "Hi, this is the message to be echoed"}, DesiredOutcomes=[])
+    
+    response : Models.UnityPredictEngineResponse = platformInit.run_engine(request=request)
+
+    # Print Outputs
+    if (response.EngineOutputs != None):
+        print ("Output: {}".format(response.EngineOutputs.toJSON()))
+    
+    # Print Error Messages (if any)
+    print ("Error Messages: {}".format(response.ErrorMessages))
+    
+```
+
+
+## Contributing
+
+## License

unitypredict-0.1.17/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

unitypredict-0.1.17/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup, find_packages
+
+description = ""
+with open("README.md", "r") as rdf:
+    description = rdf.read()
+
+print ("Possible packages: {}".format(find_packages()))
+
+setup (
+    name="unitypredict",
+    version="0.1.17",
+    packages=find_packages(),
+    install_requires=[
+        # Currently no dependencies
+    ],
+    entry_points = {          # this here is the magic that binds your function into a callable script
+        'console_scripts': 
+        [
+            'unitypredict=unitypredict.scripts:runcmd'
+        ],
+    },
+    long_description=description,
+    long_description_content_type="text/markdown"
+)

unitypredict-0.1.17/unitypredict/Models.py

@@ -0,0 +1,104 @@
+from enum import Enum
+from pydantic import BaseModel
+import json
+
+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 (BaseModel):
+    Name: str = ''
+    InputType: DataTypes = DataTypes.Integer
+
+class OutcomeInfo (BaseModel):
+    Name: str = ''
+    OutcomeType: DataTypes = DataTypes.Integer
+    
+class BasePredictEngineConfig (BaseModel):    
+    # Inputs: list[InputInfo] = None
+    # Outcomes: list[OutcomeInfo] = None
+    Inputs: list
+    Outcomes: list
+
+class InferenceContext (BaseModel):
+    ContextId: str = ''
+    StoredMeta: dict = {}
+
+    def toJSON(self):
+        return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
+
+class EngineInputs (BaseModel):     
+    InputValues: dict
+    DesiredOutcomes: list    
+
+# Note: these models will be different for every engine type
+###############################################################################################################    
+class AppEngineInferenceOptions (BaseModel):    
+    pass
+
+class AIEngineConfiguration (BasePredictEngineConfig):    
+    InferenceOptions: AppEngineInferenceOptions = None
+
+class AppEngineRequest (BaseModel):    
+    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-0.1.17/unitypredict/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-0.1.17/unitypredict/UnityPredictLocalHost.py

@@ -0,0 +1,447 @@
+import importlib
+from io import BufferedReader, IOBase, StringIO
+
+from pydantic import BaseModel
+import json
+import os, sys
+import shutil
+import datetime
+import uuid
+import filecmp
+
+import requests
+from .Models import AppEngineRequest, EngineResults, InferenceContext, UnityPredictEngineResponse
+from .Platform import ChainedInferenceRequest, ChainedInferenceResponse, FileReceivedObj, FileTransmissionObj, IPlatform, InferenceRequest,InferenceResponse, InferenceContextData
+
+class AppEngineConfig (BaseModel):
+    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()
+
+            with open(self.configFile, "w+") as confFile:
+                confFile.write(self.appEngineConfig.toJSON())
+
+            return None
+        
+        print ("Config file detected, loading data from: {}".format(self.configFile))
+        with open (self.configFile, "r+") as confFile:
+            config_dict = json.load(confFile)
+            
+        self.appEngineConfig = AppEngineConfig(**config_dict)
+        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:
+        # ToDo: return the correct path
+        return self.CurrentRequest.ModelFilesFolderPath
+    
+    def getModelFile(self, modelFileName: str, mode: str = 'rb') -> IOBase:
+        # ToDo: return the correct file handle
+        absFilePath = os.path.join(self.getModelsFolderPath(), modelFileName)
+        fileHandler = open(absFilePath, mode)
+
+        return fileHandler
+    
+
+    def getLocalTempFolderPath(self) -> str: 
+        # ToDo: return the correct path
+        return self.workingDir
+    
+    def getRequestFolderPath(self) -> str:
+        # ToDo: return the correct path
+        return self.CurrentRequest.RequestFilesFolderPath
+
+        
+    def getRequestFile(self, requestFileName: str, mode: str = 'rb') -> IOBase: 
+        # ToDo: return the correct file handle
+        absFilePath = os.path.join(self.getRequestFolderPath(), requestFileName)
+        fileHandler = open(absFilePath, mode)
+
+        return fileHandler
+    
+    def saveRequestFile(self, requestFileName: str, mode: str = 'wb') -> IOBase: 
+        # ToDo: return the correct file handle
+        absFilePath = os.path.join(self.execOutputFolder, requestFileName)
+        fileHandler = open(absFilePath, mode)
+
+        return fileHandler
+    
+    
+    def logMsg(self, msg: str):
+        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 = self.CurrentRequest.PredictEndpoint.rstrip('/')
+
+        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 {}".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 {}".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 {}".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 {}".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 {}".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 {}".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 {}".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-0.1.17/unitypredict/__init__.py

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

unitypredict-0.1.17/unitypredict/scripts.py

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

unitypredict-0.1.17/unitypredict.egg-info/PKG-INFO

@@ -0,0 +1,220 @@
+Metadata-Version: 2.1
+Name: unitypredict
+Version: 0.1.17
+Description-Content-Type: text/markdown
+
+# UnityPredict Local App Engine Creator
+
+## Introduction
+
+This library allows you to create App Engines in your local system and finetune the engines before updating it to the [ModelCentral](https://modelcentral.ai) repositories.
+
+## Installation
+* You can use pip to install the ```UnityPredict``` library.
+```bash
+pip install UnityPredict
+```
+
+## Usage
+Use the following snippet to initialize the environment.
+
+
+### main.py
+
+```python
+
+from UnityPredict import UnityPredictHost, Models
+import sys
+import uuid
+
+import time
+
+import os
+
+
+
+if __name__ == "__main__":        
+    platformInit = UnityPredictHost()
+
+    configStat = platformInit.isConfigInitialized()
+
+    if not configStat:
+        print ("Config Initialization Unsuccessful!!")
+        sys.exit(0)
+    
+    
+    print ("Config Initialization Successful!!")
+
+```
+
+* This is the snippet to initialize the AppEngine environment.
+* Run script using the following command:
+
+```bash
+python main.py
+```
+
+* If this script is run for the **first time**. The following Output will be shown
+
+```bash
+
+Config file not detected, creating templated config file: YourScriptPath/config.json
+Config Initialization Unsuccessful!!
+
+```
+* A templated config file would be generated on the same directory as that of your main script.
+
+```json
+{
+    "MODEL_DIR": "YourScriptPath/models",
+    "REQUEST_DIR": "YourScriptPath/requests",
+    "SAVE_CONTEXT": true,
+    "TEMP_EXEC_DIR": "YourScriptPath",
+    "UPT_API_KEY": ""
+}
+
+```
+
+* Edit the JSON as per your requirements. The various keys represent:
+
+    * **TEMP_EXEC_DIR**: Directory on which you wan the AppEngine to run
+    
+    * **REQUEST_DIR**: Files or Folders to be uploaded to AppEngine for using during the execution can be added under the specified **REQUEST_DIR**
+
+    * **MODEL_DIR**: Local model files/binaries to be uploaded to AppEngine for using during the execution can be added under the specified **MODEL_DIR**
+
+    * **SAVE_CONTEXT**: Retains context across multiple requests. Disable it using ```"SAVE_CONTEXT" : false```
+
+    * **UPT_API_KEY**: API Key token generated from the ModelCentral profile of the user.
+
+* Once configured, run the following script once again to get:
+
+```bash
+Config Initialization Successful!!
+```
+
+### EntryPoint.py
+
+* In order to run your custom AppEngine, it is necessary to create a file named ```EntryPoint.py``` which is going to contain the inference logic.
+
+This is an Example snippet of the `EntryPoint.py`:
+```python
+import json
+from UnityPredict.Platform import IPlatform, InferenceRequest, InferenceResponse, OutcomeValue, InferenceContextData
+from typing import List, Dict, Optional
+from collections import deque
+import sys
+import datetime
+
+
+
+def run_local_engine(request: InferenceRequest, platform: IPlatform) -> InferenceResponse:
+
+    
+
+    platform.logMsg("Running User Code...")
+    response = InferenceResponse()
+    
+    context: Dict[str, str] = {}
+
+    try:
+        prompt = request.InputValues['InputMessage']
+
+        
+        # Saved context across requests
+        # Use this variable to save new context in the dict format
+        # request.Context.StoredMeta is of the format: Dict[str, str]
+        context = request.Context.StoredMeta
+
+        currentExecTime = datetime.datetime.now()
+        currentExecTime = currentExecTime.strftime("%d-%m-%YT%H-%M-%S")
+        resp_message = "Echo message: {} Time:: {}".format(prompt, currentExecTime)
+
+        
+        # platform.getRequestFile: Fetch Files specified under the "REQUEST_DIR" in config
+        with platform.getRequestFile("myDetails.txt", "r") as reqFile:
+
+            resp_message += "\n{}".format("\n".join(reqFile.readlines()))
+
+        
+        # Fill context according to your needs
+        context[currentExecTime] = resp_message    
+        
+        
+        # platform.saveRequestFile: Creates any file type Outputs
+        # These files would be present under TEMP_EXEC_DIR/execTmp/outputs_<RequestLaunchTimeStamp>__<RequestId>
+        # TEMP_EXEC_DIR: Configured under the config.json
+        # execTmp: Creates enviroment for the AppEngine under the specified TEMP_EXEC_DIR
+        with platform.saveRequestFile("final_resp_{}.txt".format(currentExecTime), "w+") as outFile:
+
+            outFile.write(resp_message)
+
+        
+        cost = len(prompt)/1000 * 0.03 + len(resp_message)/1000 * 0.06
+        response.AdditionalInferenceCosts = cost
+        response.Outcomes['OutputMessage'] = [OutcomeValue(value=resp_message, probability=1.0)]
+        
+        # Set the updated context back to the response
+        response.Context.StoredMeta = context
+    except Exception as e:
+        response.ErrorMessages = "Entrypoint Exception Occured: {}".format(str(e))
+
+    print("Finished Running User Code...")
+    return response
+
+
+```
+
+* Some APIs for using the AppEngine environment
+    * **request.Context.StoredMeta**:
+        * Saved context across requests
+        * Use this variable to save new context in the dict format
+        * request.Context.StoredMeta is of the format: Dict[str, str]
+
+    * **platform.getRequestFile**: 
+        * Fetch Files specified under the "**REQUEST_DIR**" in config
+
+    * **platform.saveRequestFile**: 
+        * Creates any file type Outputs
+        * These files would be present under **TEMP_EXEC_DIR/execTmp/*outputs_RequestLaunchTimeStamp__RequestId***
+        * **TEMP_EXEC_DIR**: Configured under the config.json
+        * execTmp: Creates enviroment for the AppEngine under the specified TEMP_EXEC_DIR
+
+
+* Go back to the `main.py` and add the following command to run your `EntryPoint.py`
+
+```python
+if __name__ == "__main__":        
+    
+    # Previous Snippet for initialization
+    platformInit = UnityPredictHost()
+
+    configStat = platformInit.isConfigInitialized()
+
+    if not configStat:
+        print ("Config Initialization Unsuccessful!!")
+        sys.exit(0)
+    
+    
+    print ("Config Initialization Successful!!")
+
+    #### New Snippet to run EntryPoint.py via the AppEngine
+
+    request = Models.AppEngineRequest(RequestId=str(uuid.uuid4()))
+    request.EngineInputData = Models.EngineInputs(InputValues={"InputMessage": "Hi, this is the message to be echoed"}, DesiredOutcomes=[])
+    
+    response : Models.UnityPredictEngineResponse = platformInit.run_engine(request=request)
+
+    # Print Outputs
+    if (response.EngineOutputs != None):
+        print ("Output: {}".format(response.EngineOutputs.toJSON()))
+    
+    # Print Error Messages (if any)
+    print ("Error Messages: {}".format(response.ErrorMessages))
+    
+```
+
+
+## Contributing
+
+## License

unitypredict-0.1.17/unitypredict.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+unitypredict/Models.py
+unitypredict/Platform.py
+unitypredict/UnityPredictLocalHost.py
+unitypredict/__init__.py
+unitypredict/scripts.py
+unitypredict.egg-info/PKG-INFO
+unitypredict.egg-info/SOURCES.txt
+unitypredict.egg-info/dependency_links.txt
+unitypredict.egg-info/entry_points.txt
+unitypredict.egg-info/top_level.txt

unitypredict-0.1.17/unitypredict.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

unitypredict-0.1.17/unitypredict.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+unitypredict = unitypredict.scripts:runcmd

unitypredict-0.1.17/unitypredict.egg-info/top_level.txt

@@ -0,0 +1 @@
+unitypredict