unitypredict 0.1.18__tar.gz → 1.1.43__tar.gz

unitypredict-1.1.43/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.1
+Name: unitypredict
+Version: 1.1.43
+Summary:  
+Home-page: https://unitypredict.com
+Author: UnityPredict
+License:  
+Platform: UNKNOWN
+Description-Content-Type: text/markdown
+
+# UnityPredict API SDK
+
+
+## Installation
+* You can use pip to install the ```unitypredict``` library.
+```bash
+pip install unitypredict
+```
+
+## Usage
+
+TFor detailed instructions on how to use the SDK, please refer to [Unitypredict API SDK](https://docs.unitypredict.com/sdk).
+
+
+
+
+## License
+Copyright 2024 Unified Predictive Technologies
+
+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-1.1.43/README.md

@@ -0,0 +1,30 @@
+# UnityPredict API SDK
+
+
+## Installation
+* You can use pip to install the ```unitypredict``` library.
+```bash
+pip install unitypredict
+```
+
+## Usage
+
+TFor detailed instructions on how to use the SDK, please refer to [Unitypredict API SDK](https://docs.unitypredict.com/sdk).
+
+
+
+
+## License
+Copyright 2024 Unified Predictive Technologies
+
+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-0.1.18 → unitypredict-1.1.43}/setup.py

@@ -1,24 +1,32 @@
 from setuptools import setup, find_packages
+import os, sys
+
+
+packageVersion = os.getenv("PyLibVersion", "0.0.1")
+print ("Setting up package version: {}".format(packageVersion))
+
 
 description = ""
 with open("README.md", "r") as rdf:
     description = rdf.read()
 
-print ("Possible packages: {}".format(find_packages()))
 
 setup (
     name="unitypredict",
-    version="0.1.18",
+    version=packageVersion,
     packages=find_packages(),
     install_requires=[
         # Currently no dependencies
+        "attr",
+        "cattrs",
+        "requests",
     ],
     entry_points = {          # this here is the magic that binds your function into a callable script
-        'console_scripts': 
-        [
-            'uptools=unitypredict.scripts:main'
-        ],
     },
+    description=" ",
     long_description=description,
-    long_description_content_type="text/markdown"
+    long_description_content_type="text/markdown",
+    license=" ",
+    url="https://unitypredict.com",
+    author="UnityPredict"
 )

unitypredict-1.1.43/unitypredict/UnityPredictClient.py

@@ -0,0 +1,331 @@
+
+from io import IOBase
+import json
+import os
+import time
+
+import requests
+
+class UnityPredictFileTransmitDto:
+    FileName: str = ''
+    FileHandle: IOBase = None
+
+    def __init__(self, fileName, fileHandle):
+        self.FileName = fileName
+        self.FileHandle = fileHandle
+
+class UnityPredictFileReceivedDto:
+    FileName: str = ''
+    LocalFilePath: str = ''
+
+    def __init__(self, fileName, localFilePath):
+        self.FileName = fileName
+        self.LocalFilePath = localFilePath
+
+class UnityPredictRequest:
+    ContextId: str = ''
+    InputValues: dict
+    DesiredOutcomes: list
+    OutputFolderPath: str
+
+    def __init__(self, ContextId='', InputValues={}, DesiredOutcomes=[], OutputFolderPath=""):
+        self.ContextId = ContextId 
+        self.InputValues = InputValues 
+        self.DesiredOutcomes = DesiredOutcomes 
+        self.OutputFolderPath = OutputFolderPath 
+
+    
+class UnityPredictResponse:
+    ContextId: str = ''
+    RequestId: str = ''
+    ErrorMessages: str = ''
+    ComputeCost: float = 0.0
+    OutcomeValues: dict = {}
+    Outcomes: dict = {}
+    Status: str|None = None
+        
+class UnityPredictClient:
+    ApiKey: str = ''
+    ApiBaseUrl: str = 'https://api.prod.unitypredict.com/api'
+    ApiMaxTimeout: int = 12 * 60 * 60
+
+    # Async Variables
+    _asyncResult: UnityPredictResponse = None
+    _asyncResponseJson: any = {}
+
+    def __init__(self, apiKey, apiMaxTimeoutInSec = 12 * 60 * 60):
+        self.ApiKey = f"APIKEY@{apiKey}"
+        self.ApiMaxTimeout = apiMaxTimeoutInSec
+        self._asyncResult = UnityPredictResponse()
+
+
+
+    def _uploadFileAndStartPredict(self, modelId: str, request: UnityPredictRequest):
+
+        apiKey = self.ApiKey
+        apiBaseUrl = self.ApiBaseUrl
+
+        results = UnityPredictResponse()
+        needFileUpload = 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
+        for xvarName in request.InputValues:
+            if isinstance(request.InputValues.get(xvarName), UnityPredictFileTransmitDto):
+                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 = "{}/predict/{}".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
+            print ("Initializing Platform ...")
+            response = requests.post(url = "{}/predict/initialize/{}".format(apiBaseUrl, modelId), data="", headers={"Authorization": "Bearer {}".format(apiKey)})
+
+
+            if response.status_code != 200:
+                results.ErrorMessages = 'Error from server: {}'.format(response.status_code)
+                return (results, {})
+            
+            print ("Platform Initialized!")
+            requestId: str = response.json().get('requestId')
+
+            # print (f"Initialized request: {requestId}")
+            
+            # upload the files
+            for xvarName in request.InputValues: 
+                if isinstance(request.InputValues.get(xvarName), UnityPredictFileTransmitDto):
+                    fileToUpload: UnityPredictFileTransmitDto = request.InputValues.get(xvarName)
+                    print (f"Uploading {fileToUpload.FileName}...")
+                    response = requests.get(url = "{}/predict/upload/{}/{}".format(apiBaseUrl, requestId, fileToUpload.FileName), headers={"Authorization": "Bearer {}".format(apiKey)})
+                    if response.status_code != 200:
+                        results.ErrorMessages = 'Error from server: {}'.format(response.status_code)
+                        return (results, {})
+                    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)
+                    print (f"Upload file {fileToUpload.FileName} Success!")
+            
+            # print (f"Input request: {request.InputValues}")
+            jsonBody = json.dumps(request, default=vars)
+            
+            # print (f"URL: {"{}/predict/{}/{}".format(apiBaseUrl, modelId, requestId)}, body: {jsonBody}")
+            response = requests.post(url = "{}/predict/{}/{}".format(apiBaseUrl, modelId, requestId), 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()
+
+        return (results, finalResponseJson)
+    
+
+    def _processPredictedInference(self, responseJson: any, outputFolderPath: str = ""):
+        
+        results = UnityPredictResponse()
+
+        apiKey = self.ApiKey
+        apiBaseUrl = self.ApiBaseUrl
+        finalResponseJson = responseJson
+        
+        finalResponseRequestId: str = finalResponseJson.get('requestId')
+
+        outcomeValues = finalResponseJson.get('outcomeValues')
+        for outputVarName in outcomeValues: 
+            outcome: dict = outcomeValues.get(outputVarName)
+            if outcome.get('dataType') == 'File':
+                
+                tempOutputFolder: str = os.path.join(outputFolderPath, "chainedResults", finalResponseRequestId)
+                if not os.path.exists(tempOutputFolder):
+                    os.makedirs(tempOutputFolder)
+                
+                fileName = outcome.get('value')
+
+                tempFilePath = os.path.join(tempOutputFolder, fileName)
+                response = requests.get(url = "{}/predict/download/{}/{}".format(apiBaseUrl, finalResponseRequestId, fileName), headers={"Authorization": "Bearer {}".format(apiKey)})
+                with open(tempFilePath, 'wb') as f:
+                    f.write(response.content)
+
+                fileReceived: UnityPredictFileReceivedDto = UnityPredictFileReceivedDto(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 = "{}/predict/download/{}/{}".format(apiBaseUrl, finalResponseRequestId, fileName), headers={"Authorization": "Bearer {}".format(apiKey)})
+                    with open(tempFilePath, 'wb') as f:
+                        f.write(response.content)
+
+                    fileReceived: UnityPredictFileReceivedDto = UnityPredictFileReceivedDto(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
+    
+    
+    def Predict(self, modelId: str, request: UnityPredictRequest) -> UnityPredictResponse:
+            results = UnityPredictResponse()
+
+            apiKey = self.ApiKey
+            apiBaseUrl = self.ApiBaseUrl
+
+            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
+
+            
+            results, finalResponseJson = self._uploadFileAndStartPredict(modelId=modelId, request=request)
+
+            if (finalResponseJson == {}):
+                return results
+
+            statusUrl = ''
+            if (finalResponseJson.get('status') == 'Processing'):
+                statusUrl = finalResponseJson.get('statusUrl') # this is probably a long-running inference
+
+            loopCount = 0
+            startTime = time.time()
+            maxPredictTime = self.ApiMaxTimeout
+            maxTimeExceed = False
+            print (f"Starting max inference timer for {maxPredictTime} Seconds")
+            while finalResponseJson.get('status') == 'Processing': # todo: add timeout in UnityPredictRequest
+                
+                if ((time.time() - startTime) > maxPredictTime):
+                    print (f"Max time limit of {maxPredictTime} seconds exceeded!")
+                    maxTimeExceed = True
+                    break
+                
+                response = requests.get(url = statusUrl, headers={"Authorization": "Bearer {}".format(apiKey)})
+                finalResponseJson = response.json()
+
+                delay = min(loopCount * 2, 30)
+                time.sleep(delay)
+
+                loopCount = loopCount + 1
+
+                print('Waiting {} seconds for job to finish...'.format(delay))
+
+            if maxTimeExceed:
+                results = UnityPredictResponse()
+                results.Status = None
+                results.ErrorMessages = f"Max time limit of {maxPredictTime} seconds exceeded!"
+                return results
+            
+            try:
+                results = self._processPredictedInference(responseJson=finalResponseJson, outputFolderPath=request.OutputFolderPath)
+                results.Status = finalResponseJson.get('status')
+            except Exception as e:
+                results = UnityPredictResponse()
+                results.Status = None
+                results.ErrorMessages = f"Exception Occured while processing Inference: {e}"
+
+            return results
+    
+    def AsyncPredict(self, modelId: str, request: UnityPredictRequest):
+
+        ##### 
+        # 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
+
+        try:
+        
+            results, finalResponseJson = self._uploadFileAndStartPredict(modelId=modelId, request=request)
+
+            self._asyncResult = results
+            self._asyncResponseJson = finalResponseJson
+    
+        except Exception as e:
+            
+            self._asyncResult.ErrorMessages = f"Predict Exception Occured: {e}"
+        
+    
+    def AsyncInference(self, outputFolderPath: str = ""):
+
+        self._asyncResult.Status = self._asyncResponseJson.get("status", None)
+        statusUrl = self._asyncResponseJson.get('statusUrl', None)
+
+        apiKey = self.ApiKey
+        
+        inferStatus = self._asyncResult.Status
+        if inferStatus == 'Processing':
+
+            if statusUrl == None:
+                self._asyncResult.Status = None
+                return self._asyncResult
+
+            response = requests.get(url = statusUrl, headers={"Authorization": "Bearer {}".format(apiKey)})
+            finalResponseJson = response.json()
+
+            inferStatus = finalResponseJson.get('status', None)
+            self._asyncResult.Status = inferStatus
+            
+            if (inferStatus == None):
+                return self._asyncResult
+            
+            if (inferStatus == 'Processing'):
+                return self._asyncResult
+            
+        elif inferStatus == None:
+            return self._asyncResult
+        
+        else:
+            finalResponseJson = self._asyncResponseJson
+
+        
+        # Once the processing is done
+        
+        try:
+            self._asyncResult = self._processPredictedInference(responseJson=finalResponseJson, outputFolderPath=outputFolderPath)
+            self._asyncResult.Status = inferStatus
+        except Exception as e:
+            self._asyncResult = UnityPredictResponse()
+            self._asyncResult.ErrorMessages = f"Exception Occured while processing Inference: {e}"
+        
+        return self._asyncResult
+    
+    def AsyncResponse(self):
+
+        return self._asyncResponseJson
+
+        
+
+        
+
+        

unitypredict-1.1.43/unitypredict/__init__.py

@@ -0,0 +1 @@
+from .UnityPredictClient import *

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

@@ -0,0 +1,41 @@
+Metadata-Version: 2.1
+Name: unitypredict
+Version: 1.1.43
+Summary:  
+Home-page: https://unitypredict.com
+Author: UnityPredict
+License:  
+Platform: UNKNOWN
+Description-Content-Type: text/markdown
+
+# UnityPredict API SDK
+
+
+## Installation
+* You can use pip to install the ```unitypredict``` library.
+```bash
+pip install unitypredict
+```
+
+## Usage
+
+TFor detailed instructions on how to use the SDK, please refer to [Unitypredict API SDK](https://docs.unitypredict.com/sdk).
+
+
+
+
+## License
+Copyright 2024 Unified Predictive Technologies
+
+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-1.1.43/unitypredict.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+setup.py
+unitypredict/UnityPredictClient.py
+unitypredict/__init__.py
+unitypredict.egg-info/PKG-INFO
+unitypredict.egg-info/SOURCES.txt
+unitypredict.egg-info/dependency_links.txt
+unitypredict.egg-info/requires.txt
+unitypredict.egg-info/top_level.txt

unitypredict-1.1.43/unitypredict.egg-info/requires.txt

@@ -0,0 +1,3 @@
+attr
+cattrs
+requests