Using Python script inside QGIS Graphic Modeler

Question

I created a model that combines two vector layers and outputs a single layer with aggregated data. I have a Python script that calculates the Chi-square, and I would like it to be executed at the end of the model's execution.

How do I incorporate the Chi-square code into the modeler?

script Chi-square:

import numpy as np
from scipy.stats import chisquare, norm
from qgis.gui import QgsFieldComboBox, QgsDoubleSpinBox
from qgis.PyQt.QtWidgets import QInputDialog, QMessageBox
# Função para calcular os valores críticos com base no novo valor de alfa corrigido
def calcular_valores_criticos(alfa_corrigido):
 # Calcular os valores críticos da distribuição normal padrão
 limite_superior = norm.ppf(1 - alfa_corrigido / 2)
 limite_inferior = norm.ppf(alfa_corrigido / 2)
 return limite_superior, limite_inferior
# Função para realizar o teste qui-quadrado de aderência com correção de Bonferroni
def qui_quadrado_aderencia_qgis(camada, campo_esperado, campo_observado, alfa):
 # Verificar se a camada está carregada
 if not camada:
 print("Camada inválida. Verifique se uma camada está ativa.")
 return
 # Inicializar listas para valores esperados e observados
 valores_esperados = []
 valores_observados = []
 # Acessar os dados da camada e extrair os valores esperados e observados
 for feature in camada.getFeatures():
 valor_esperado = feature[campo_esperado]
 valor_observado = feature[campo_observado]
 if isinstance(valor_esperado, (int, float)) and isinstance(valor_observado, (int, float)):
 valores_esperados.append(float(valor_esperado))
 valores_observados.append(float(valor_observado))
 # Executar o teste qui-quadrado de aderência
 chi2, p_valor = chisquare(valores_observados, f_exp=valores_esperados)
 # Calcular os resíduos padronizados ajustados
 res_padronizados = (np.array(valores_observados) - np.array(valores_esperados)) / np.sqrt(valores_esperados)
 # Aplicar a correção de Bonferroni ao valor de alfa
 p_valor_corrigido = p_valor * len(valores_esperados) # Número de testes multiplicado pelo p-valor original
 alfa_corrigido = alfa / len(valores_esperados)
 # Calcular os valores críticos com base no novo valor de alfa corrigido
 limite_superior, limite_inferior = calcular_valores_criticos(alfa_corrigido)
 # Imprimir os resultados
 print("Estatística qui-quadrado:", chi2)
 print("Valor-p:", p_valor)
 print("Valor-p corrigido (Bonferroni):", p_valor_corrigido)
 print("Resíduos Padronizados:")
 print(res_padronizados)
 print(f"Valores críticos para alfa corrigido ({alfa_corrigido}):")
 print(f"Limite Superior: {limite_superior}")
 print(f"Limite Inferior: {limite_inferior}")
 # Interpretar o resultado com a correção de Bonferroni
 if p_valor_corrigido < alfa_corrigido:
 print("Rejeitar a hipótese nula: A distribuição do fenômeno analisado não possui carácter aleatório (com correção de Bonferroni).")
 else:
 print("Falha em rejeitar a hipótese nula: A distribuição do fenômeno analisado possui carácter aleatório (com correção de Bonferroni).")
# Obter a camada ativa no QGIS
camada_ativa = iface.activeLayer()
# Usar QInputDialog para obter os campos de atributos e o valor de alfa
campo_esperado, ok = QInputDialog.getItem(None, "Campo de Valores Esperados", "Selecione o campo de valores esperados:",
 [field.name() for field in camada_ativa.fields()])
if not ok:
 QMessageBox.critical(None, "Erro", "Seleção de campo de valores esperados cancelada.")
else:
 campo_observado, ok = QInputDialog.getItem(None, "Campo de Valores Observados", "Selecione o campo de valores observados:",
 [field.name() for field in camada_ativa.fields()])
 if not ok:
 QMessageBox.critical(None, "Erro", "Seleção de campo de valores observados cancelada.")
 else:
 alfa, ok = QInputDialog.getDouble(None, "Valor de Alfa", "Digite o valor de alfa (nível de significância):", 0.05, 0, 1, 6)
 if ok:
 # Chamar a função qui_quadrado_aderencia_qgis
 qui_quadrado_aderencia_qgis(camada_ativa, campo_esperado, campo_observado, alfa)

• Kalak: I don't believe it is possible, but you could export your model, as it is with the merge of 2 vector layers), to a Python script algorithm (Model -> Export -> Export as Python Script...) and edit that script to include your Chi-square code.
• Kalak: Or as the deleted answer proposed (sorry answerer, I misread it), you can turn your Chi-square code into a Processing Algorithm and insert it inside your model.

Answer 1

It is possible to include your script into a model. I would not export the whole model and include your script. An other way is, to make a seperate process and include the process in a model. You have to get rid of all QInputDialogs and integrate inputs into the processing script. It then looks like the following script. This will produce an Inputdialog for the algorithm. You have to put your logic then in the def processAlgorithm function.

from qgis.core import QgsProcessing
from qgis.core import QgsProcessingAlgorithm
from qgis.core import QgsProcessingMultiStepFeedback
from qgis.core import QgsProcessingParameterField
from qgis.core import QgsProcessingParameterVectorLayer
from qgis.core import QgsProcessingParameterFeatureSink
import processing
import numpy as np
from scipy.stats import chisquare, norm
#Função para calcular os valores críticos com base no novo valor de alfa corrigido
def calcular_valores_criticos(alfa_corrigido):
 # Calcular os valores críticos da distribuição normal padrão
 limite_superior = norm.ppf(1 - alfa_corrigido / 2)
 limite_inferior = norm.ppf(alfa_corrigido / 2)
 return limite_superior, limite_inferior
class p_chisquare(QgsProcessingAlgorithm):
 def initAlgorithm(self, config=None):
 self.addParameter(QgsProcessingParameterVectorLayer('camada_ativa', 'camada_ativa', types=[QgsProcessing.TypeVectorAnyGeometry], defaultValue=None)) 
 self.addParameter(QgsProcessingParameterField('campo_observado', 'campo_observado', type=QgsProcessingParameterField.Any, parentLayerParameterName='camada_ativa', allowMultiple=False, defaultValue=None))
 self.addParameter(QgsProcessingParameterField('campo_esperado', 'campo_esperado', type=QgsProcessingParameterField.Any, parentLayerParameterName='camada_ativa', allowMultiple=False, defaultValue=None))
 self.addParameter(QgsProcessingParameterFeatureSink('Result', 'Result', type=QgsProcessing.TypeVectorPolygon, createByDefault=True, supportsAppend=True, defaultValue=None))
 def processAlgorithm(self, parameters, context, model_feedback):
 # Use a multi-step feedback, so that individual child algorithm progress reports are adjusted for the
 # overall progress through the model
 feedback = QgsProcessingMultiStepFeedback(1, model_feedback)
 results = {}
 outputs = {}
 
 #-->> Here comes your algorithm
 return results
 def name(self):
 return 'p_chisquare'
 def displayName(self):
 return 'chisquare'
 def group(self):
 return ''
 def groupId(self):
 return ''
 def createInstance(self):
 return p_chisquare()