Visão geral

A programação em muitos de seus projetos consistirá em código C # ou VB.NET 100% Managed , projetado para ser executado no framework Microsoft .NET.

O Action.NET agora inclui Python como uma linguagem de programação que pode ser usada em Code Behind, Scripts, Tasks e interativamente por meio de código Python externo.

Python é uma linguagem interpretada, de alto nível e de uso geral. É uma linguagem popular para Inteligencia Artificial (AI) e Machine Learning(ML), que é muito útil para utilização em algoritmos como os de manutenção preditiva.

O Action.NET pode usar qualquer versão do Python, 3.x ou a mais antiga e passada 2.x.

Os usuários podem usar Python de três maneiras diferentes:

• Usando Script> Task: Para Python: execute o código Python (.PY) e use a interface Script Task para definir e obter parâmetros (nenhum código é necessário no Studio).

• Namespace Python (Python para .Net): Crie código .Net usando o namespace Python para interagir com os objetos Python.

• Python usando o kit de ferramentas TKDataAccess: Crie o código Python usando o TKDataAccess.py (fornecido por nós) para interagir com os projetos do Studio.

Requisitos de sistema

Intérprete Python

A primeira etapa para usar a programação Python é incluir um link para a versão do interpretador Python que você deseja usar em seu projeto. Você pode baixar Python aqui.

Durante a instalação do Python Engine, é altamente recomendável escolher a opção “Instalar para todos os usuários”.

Agora você precisa adicionar o intérprete ao seu projeto. Navegue até a guia Info>Settings e vá ao quadro Python. Clique no botão, navegue para encontrar o Python Engine instalado e selecione o arquivo python.exe.

Python para .Net

Python for .NET é um pacote que oferece aos programadores Python uma integração quase perfeita com o .NET Common Language Runtime (CLR) e fornece uma ferramenta de script de aplicativo poderosa para desenvolvedores .NET.

Python para .NET permite que o código Python interaja com o CLR e pode ser usado para embutir Python em um aplicativo .NET. Os arquivos de instalação e documentação estão disponíveis aqui.

Verifique se suas versões do Python e do Windows são de 32 ou 64 bits antes de baixar o Python para .NET. Isso é necessário apenas se você pretende usar o namespace Python em Studio Scripts e Display CodeBehinds.

Criação de scripts em Python

Para criar scripts com base na linguagem de programação Python, navegue até Scripts> Tarefas, selecione uma nova linha em branco e clique duas vezes na coluna Código. Depois de clicar em Código, uma caixa de combinação aparecerá. Selecione Python na combobox.

Depois de criar uma nova tarefa de script, você precisa editá-la na guia CodeEditor.

As configurações são detalhadas a seguir:

• Nome do arquivo: Nome do arquivo .py

• Saída padrão: nome da tag que receberá todas as saídas impressas via impressão

• Argumentos: Lista de argumentos. Esta lista de parâmetros será passada como argumentos para o Python Engine (python.exe)

Depois de fazer qualquer alteração, clique no botão Apply Changes (Aplicar alterações.

Python Namespace

O namespace Python pode ser usado em qualquer editor de script (Tarefas, Classes ou CodeBehind) dentro do ambiente do projeto. Para usar o namespace Python, você simplesmente precisa instalar o pacote Python.NET, disponível no github.

O namespace Python fornece vários métodos .Net que interagem com códigos e objetos Python. Veja alguns desses métodos abaixo:

Execute um arquivo .py usando Python para .NET

string ExecutePyFile(string pyFileName, Dictionary<string, object> locals = null, bool keepValuesAsPython = false)
 
string pyFileName = Python file
Dictionary<string, object> locals = Local variables inside Python code. Default is null.
bool keepValuesAsPython = Keep retuned values as Python objects or convert to .NET objects. Default is false.
string returns = If success return null else string contains error.

Execute um código Python usando Python para .NET

string ExecuteCode(string code, string workingDirectory = null, Dictionary<string, object> locals = null, bool keepValuesAsPython = false)
 
string code = py file name
string workingDirectory = Working directory. It will be added in 'sys.path'
Dictionary<string, object> locals = Local variables inside Python code. Default is null.
bool keepValuesAsPython = Keep retuned values as Python objects or convert to .NET objects. Default is false.
string return = If success return null else string contains error.

Converta um valor Python em um valor .NET

public static object FromPython(object value)
 
object value = Python value
object returns = NET value

Copiar um objeto Python para uma tag (Array ou User Template)

public static void CopyPythonObjectToTag(object source, string tagName)
 
object source = Python object.
string tagName = Tag Array or User Template.

Copie uma tag (Array ou User Template) para um objeto Python

public static void CopyTagToPythonObject(string tagName, object target)
 
string tagName = Tag Array or User Template.
object target = Python object.

Crie um objeto Python a partir de uma classe Python

public static object CreatePythonObjectFromPyFile(string pyFileName, string className, object[] parameters = null, string tagName = null)
 
string pyFileName = Python file name containg the definition of Python class.
string className = Python class name.
object[] parameters = Parameters for Python class while creating Python object.
string tagName = Tag name (Optional, Tag Array or User Template). If tag exists then copy all values to new Python object.
object returns = Reference to new Python object.

Obtenha todos os atributos de um objeto Python

public static IDictionary<string, object> GetAttributesPythonObject(object pythonObject, bool keepValuesAsPython = false)
 
object pythonObject = Python object/
bool keepValuesAsPython = Keep retuned values as Python objects or convert to .NET objects. Default is false.
IDictionary<string, object> = Dictionary contains attributes (name and value).

Defina um novo valor para os atributos de um objeto Python

public static void SetAttributesPythonObject(object pythonObject, IDictionary<string, object> dic)
 
object pythonObject = Python object.
IDictionary<string, object> = Dictionary contains attributes (name and value) for setting.

Despeje um objeto Python em uma string para enviá-lo a uma TraceWindow

public static string DumpPythonObjectToString(object pythonObject)
 
object pythonObject = Python object.
string returns = Dump information of object.

TKDataAccess.py

Você pode criar código no ambiente Python e usar o arquivo TKDataAccess.py para interagir com os projetos.

O Action.NET fornece o arquivo TKDataAccess.py. Ao usá-lo, você precisa ter certeza de que o installPath no arquivo TKDataAccess.py está com o caminho correto da instalação do Action.NET.

Abaixo estão alguns métodos de TKDataAccess.py que você pode usar:

• Abra uma conexão com o servidor
  

  Connect(runtimeHostAddress, userName, password):
   
  runtimeHostAddress  =  IP address or server name
  userName  = User name.
  password = Password

• Obtenha um status de conexão do servidor

  GetConnectionStatus ()                 

• Verifique a conexão do seu script com o servidor

  IsConnected ()

• Desconectar do servidor

Disconnect()

• Defina um flag de espera de um valor do servidor
  

  SetSyncFlag(flag): 
  flag = True wait value from server, false does not wait value from server.

• Recupere um valor atual

GetObjectValue(name)
 
name = TagName

• Defina um novo valor para um objeto

SetObjectValue(name, newValue)
 
name = TagName
newValue = new value to set in the tag.

• Execute um método de um ScriptClass remoto
  

  ExecuteClassMethodOnServer(className, methodName, parameters)
   
  className = name of the class in the remote project.
  methodName = name of the method in the remote class.
  parameters = if any, necessary to the invoke the remove method.

Examplo

As seções a seguir contêm diferentes maneiras de usar Python em um projeto.

Usando namespace em CodeBehind

Neste exemplo, existem dois parâmetros de entrada chamados val1 e val2 que serão resumidos e o resultado será armazenado na variável de resultado.

O código que executa esta ação é apresentado a seguir.

//Defining where locate the .py files that will use
string  pyDefinition  =  @Info.GetExecutionFolder()  +  @"\Calc\algorithm.py"; string pyWorkingFolder = @Info.GetExecutionFolder();
 
try
{
string error;
Dictionary<string,  object>  param  =  new  Dictionary<string,  object>();
 
       //Defining the used imports from Python 
string imports = "";
imports += "import sys" + Environment.NewLine;
imports += "from Calc.algorithm import Algorithm" + Environment.NewLine;
 
      //Creating a .Net object from a Python object
object algorithm =Python.CreatePythonObjectFromPyFile(pyDefinition, "Algorithm", null);
//Creating a .Net object from a Python object  
object val1 = Python.ToPython(@Tag.val1);
object val2 = Python.ToPython(@Tag.val2);
 
      //Setting the parameters with the .Net objects that will be used to execute the Python code
param.Clear(); param.Add("algorithm", algorithm); param.Add("val1", val1);
param.Add("val2", val2);
 
      //Call method to execute Python code
error  =  Python.ExecuteCode("result  =  algorithm.Sum(val1,  val2)",  pyWorkingFolder,  param,  true);
 
if (!string.IsNullOrEmpty(error))
throw new Exception(error);
 
       //Set .Net object with result Python object , return of algorithm.Sum Python method
object result = param["result"];
 
//Copy .Net object to Tag
Python.CopyPythonObjectToTag(result, @Tag.result.GetName());
}
catch (Exception ex)
{
@Info.Trace("Python: " + (ex.InnerException == null ? ex.Message : ex.InnerException.Message));
}

Usando Tasks

Neste cenário, configuramos uma tarefa para a linguagem Python. No campo de nome do arquivo Python, você precisa definir o arquivo Python que será executado. Neste exemplo, usamos Main2.py.

No campo Saída padrão, selecionamos uma tag chamada output. Este tipo de tag deve ser texto. No campo Argumentos, selecionamos outro tipo de tag chamado script.

Usando o método de impressão, o arquivo Python chamado Main2.py recupera os dados de entrada e produz seu valor dentro de uma string. O sys.argv receberá o Tag.script e o tag de saída receberá todos os valores do método print ().

import sys
 
value = sys.argv[1] print("Value: " + value) print("That’s  all  folks!")

Usando TKDataAccess.py

Neste exemplo, você precisa chamar um arquivo denominado Main.py, que contém o código que copia o conteúdo de tag1 (origem) para tag2 (destino).

O código Python usando o módulo TKDataAccess.py em Main.py é descrito abaixo:

import sys
from Extensions.TKDataAccess import TKDataAccess dataAccess = TKDataAccess()
connectionStatus = dataAccess.Connect("127.0.0.1:3101", "guest", "") print("Connection: " + connectionStatus)
 
if dataAccess.IsConnected() :
ret  =  dataAccess.GetObjectValue("Tag.tag1") print("Value: " + str(ret)) dataAccess.SetObjectValue("Tag.tag2",  ret)
 
dataAccess.Disconnect()

Então, você precisa criar o código que é mostrado abaixo ou criar uma Tarefa de Script Python que execute o arquivo Main.py, que contém a chamada para TKDataAccess mostrado acima. Então, aqui, usaremos o namespace Python conforme descrito anteriormente.

O código é mostrado abaixo.

try
{
string  error  =  Python.ExecutePyFile(@Info.GetExecutionFolder()  +  @"\Main.py",  null,  true); if (!string.IsNullOrEmpty(error))
throw new Exception(error);
}
catch (Exception ex)
{
@Info.Trace("Python: " + (ex.InnerException == null ? ex.Message : ex.InnerException.Message));
}