This solution demonstrates the four scenarios on how you can use Python in your solution:
- Python Shell
- Python Standard
- Python and .NET Intermixed
- Python DataAccess API
Each integration method handles tag values, external scripts, or Python classes differently, and they are triggered by either tag changes or button presses. Below is a breakdown of each method:
Python Shell Integration
This integration calls external Python files, passing optional arguments to it, and uses he Python Shell to execute the code capturing the output back to the solution.
Code Block |
---|
language | py |
---|
title | Shell Integration example |
---|
|
# This code call the execution of the external file using Python Shell
# with the optional args defined in this initial section
#
# The macro _ExecutionPath_ is replaced by the path where the solution is set to execute
# Replace that macro by a specific path, or user other built-in macros as nedded
#
arg1 = @Tag.Tag1
arg2 = @Tag.Tag2
result = TK.ExecutePythonShell("_ExecutionPath_ExternalSum.py", [arg1, arg2])
@Tag.Result = result |
The method TK.ExecutePythonShell() runs the external python interpreter capturing the ouput, and using the result in the code.
Execution: When this tasks is executed, the script ExternalSum.py
is called, with the values of Tag.Tag1
and Tag.Tag2
passed as arguments. The result, captured from the Print output is captures, and it is stored in Tag.Result(0)
.
Tip |
---|
title | Python Shell Version and Tests |
---|
|
When creating Script > Tasks, with this method, the Play Button in the top toolbar, will execute the Python code directing the printing output to the Designer Output Window. |
Anchor |
---|
| PythonStandard |
---|
| PythonStandard |
---|
|
Python Standard Integration
Edit and run the Python code within the platform, with no needing for external files.
When creating a new Task, or a new Class, select Python for the language.
Code Block |
---|
language | py |
---|
title | Example of. Script Task |
---|
|
def sub(val1, val2):
return val1 - val2
result = sub(@Tag.Tag1[1], @Tag.Tag2[1])
@Tag.Result[1] = result |
Tip |
---|
This scenario and the previous one are both relying in the Python interpreter to evaluate the Python code. The difference is that in the first one the python file is external to the solution, and in this one the Python code is saved inside the Solution file. |
Anchor |
---|
| PythonNetIntermixed |
---|
| PythonNetIntermixed |
---|
|
Python and .NET Intermixed
This integration allows C# and VB.Net to call directly methods written and Python, and the Python to consume methods written in .NET languages.
This is demonstrated in the Python.dbsln demo, when the button is pressed, the following C# expression is executed:
Code Block |
---|
|
Script.Class.ClassPython.sum(Tag.Tag[1], Tag.Tag[2] |
The Script.Class.ClassPython was created in Script > Classes, using the Python language.
Code Block |
---|
|
def main(self): return def sum(self, val1, val2): return val1 + val2 def multiply(self, val1: int, val2: int): return val1 * val2 |
Anchor |
---|
| PythonDataAccessAPI |
---|
| PythonDataAccessAPI |
---|
|
Python DataAccess API
This method calls external Python scripts that use the DataAccess API, allowing for interaction with the calling solution, or other solutions in execution.
From the solution, using Scripts Tasks, the following code is executed:
Code Block |
---|
# This code call the execution of the external file using Python Shell with the optional args defined in this initial section
#
# The macro ExecutionPath is replaced by the path where the solution is set to execute
# Replace that macro by a specific path, or user other built-in macros as nedded
#
result = TK.ExecutePythonShell("_ExecutionPath_ExternalSumDataAccess.py", []) |
The external Python application will use the DataAccess API to connected with the running solution, to read and write data directly.
This is the code for the example: ExternalSumDataAccess.py
Code Block |
---|
|
# TKDataAccess is located with the product installation files
#
# If you move this code to another computer, replace the 127.0.0.1 to server you want to connect
# This code can only run on computers where the product is installed
#
# The Macros _ToolkitPath_ and _ExecutionPort_ are resolved automatically before we call this Python code
# If you call the py file directly you need to replace those macros
#
# _ToolkitPath_ should be replaced by the product binaries folder (location of T.Toolkit.DLL and other DLLs)
# _ExecutionPort_ should be replaced by the port number TServer is running, ex.: 3101 (which is dependent on the ExecutionProfile)
import sys
installPath = "_ToolkitPath_"
sysPath = ";".join(sys.path)
if sysPath.find(installPath) < 0 :
sys.path.append(installPath)
from TKDataAccess import TKDataAccess
dataAccess = TKDataAccess()
connectionStatus = dataAccess.Connect("127.0.0.1:_ExecutionPort_", "guest", "")
if dataAccess.IsConnected() :
value1 = dataAccess.GetObjectValue("Tag.Tag1[3]")
value2 = dataAccess.GetObjectValue("Tag.Tag2[3]")
ret = value1 / value2
dataAccess.SetObjectValue("Tag.Result[3]", ret)
print(str(ret))
dataAccess.Disconnect() |