public interface PythonPredictRuntimeProvider extends ModelProvider {

   PythonPredictFunction getPythonPredictFunction();
}

public abstract class PythonPredictFunction {
   /**
    * Get the Python class name for this prediction function. This python class should be an
    * implementation of PredictFunction abstract class in Python
    *
    * @return Fully qualified Python class name
    */
   public abstract String getPythonClass();

   /**
    * Get the model configuration serialized string from the context. This method should be
    * implemented by the concrete provider.
    *
    * <p>This will be passed to PredictFunction.py, where it's deserialized and required
    * properties, schema are extracted.
    *
    * @return model configuration string including the properties and serialized schema
    */
   public abstract String getModelConfig();

   /**
    * Create PythonFunctionInfo for this prediction function.
    *
    * @return PythonFunctionInfo configured for this prediction function
    */
   @Internal
   public PythonFunction createPythonFunction() {
       return PythonFunctionUtils.getPythonFunction(
               getPythonClass(),
               modelContext.getConfiguration(),
               this.getClass().getClassLoader());
   }

class PredictFunction(TableFunction):

   """
   Base class for Python-based prediction functions used in the advanced provider path.
   """
   def open(self, context):
       """
       Initialization method for the function. It is called before the predict method
       and can be used for one-time setup tasks.

       :param context: A context object that provides access to model properties and other runtime information.
       """
       if self.model_config_json is None:
           raise RuntimeError("Model config not set")

   def predict(self, data: Row) -> List[Row]:
       """
       Performs prediction on the input data.

       :param data: The input data for prediction.
       :return: A list of rows containing the prediction results.
       """
       raise NotImplementedError

   def set_model_config(self, model_config_json: str):
       """
       Set model configuration programmatically.
       This method will be called by the Java integration layer.
       Parses the JSON configuration and sets the properties directly.
       """
       self.model_config_json = model_config_json

CREATE MODEL my_python_model
INPUT (text STRING)
OUTPUT (prediction STRING, confidence FLOAT)
WITH (
   'provider' = 'generic-python',
   'model-directory-path' = '/path/to/your/model',
   'python-predict-class' = 'mymodule.MyCustomModel',
   'properties.model_version' = '1'
);

CREATE MODEL simple_python_model
  INPUT (text STRING)
  OUTPUT (sentiment STRING, confidence FLOAT)
  WITH (
      'provider' = 'generic-python',
      'model-directory-path' = '/path/to/python-models/sentiment-roberta-large-english',
      'properties.model_version' = '1',
      'python-predict-class' = 'models.HuggingFaceSentimentPredictFunction'
  )

class HuggingFaceSentimentPredictFunction(PyPredictFunction):
   """
   Hugging Face transformers-based sentiment analysis prediction function.
   """

   def open(self, context):
       """
       Initialize the function and load the Hugging Face model.

       :param context: A context object that provides access to model properties and other runtime information.
       """
       # Initialize the sentiment analysis pipeline
       self.pipeline = pipeline("sentiment-analysis", model=self.model_directory, return_all_scores=True)

   def predict(self, data: Row) -> List[Row]:
       """
       Perform sentiment prediction using Hugging Face transformers.

       :param data: The input data row for prediction (expects text field)
       :return: A list of rows containing the prediction results
       """
       text = data[0] if len(data) > 0 else ''
       results = self.pipeline(text)