Blender Python: Call operator function from another function?

Question

It looks like the best way to report a user-error to the user is by using self.report() of Operator types. However, what about when the operator calls a global function that needs to report a specific error? Is there any way to reach back to the calling operator and have it throw an error with a specific message?

The classic method to handle something like this would be to have the global function return some type of error index, then have the operator send a string that relates to the error type. But this creates a lot of relationship links between the operator and the functions it calls. If I later change the function, I have to also modify the operator.

Is there a simple way to pull this off? Either to access the "active" operator or to throw a global user error?

Answer 1

I agree with @lemon that the 'calculations should not be caller dependent'.

Here is my take... (this could be refined further, but maybe, that would be an overkill for a script):

import bpy, random

class ErrorInfo:
    SUCCESS = 0
    ERR_1 = 1
    ERR_2 = 2    

    ERROR_LOOKUP = {
        ERR_1: ['Forbidden Odd', 'Unerlaubte ungerade Zahl'],
        ERR_2: ['Forbidden Even', 'Unerlaubte gerade Zahl']
    }

    def getErrMsg(errNo, msgTypeIdx = 0):
        return ErrorInfo.ERROR_LOOKUP.get(errNo)[msgTypeIdx]

def a_function(context):
    errorVals1 = {1, 5, 3}
    errorVals2 = {2, 8}
    x = random.randint(1, 10)

    if(x in errorVals1):
        return ErrorInfo.ERR_1, x
    elif(x in errorVals2):
        return ErrorInfo.ERR_2, x
    else:
        return ErrorInfo.SUCCESS, x


class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"

    @classmethod
    def poll(cls, context):
        return context.active_object is not None

    def execute(self, context):
        errorCode, val = a_function( context )
        if(errorCode != ErrorInfo.SUCCESS):
            errMsg = ErrorInfo.getErrMsg(errorCode)
            self.report({'ERROR'}, (errMsg + ': ' + str(val)))
        else:
            self.report({'INFO'}, ('Value: ' + str(val)))
        return {'FINISHED'}

def register():
    bpy.utils.register_class(SimpleOperator)

def unregister():
    bpy.utils.unregister_class(SimpleOperator)

if __name__ == "__main__":
    register()

    # test call
    bpy.ops.object.simple_operator()

Answer 2

You can pass what you want and even self, this way it is easy determine where the call is coming from. Operator based on Templates > Python > Operator Simple:

import bpy


def main(operator, context):
    print (operator, context)
    operator.report({'INFO'}, 'Call is comming from: {}'.format(operator))
    #return operator


class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"

    @classmethod
    def poll(cls, context):
        return context.active_object is not None

    def execute(self, context):
        main(self, context)
        return {'FINISHED'}


def register():
    bpy.utils.register_class(SimpleOperator)


def unregister():
    bpy.utils.unregister_class(SimpleOperator)


if __name__ == "__main__":
    register()

    # test call
    bpy.ops.object.simple_operator()

Answer 3

I think calculations should not be 'caller dependent', because if so, you'll need to pass many additional arguments to every function called in the process.

So one way to inform a calculation has failed is simply to raise an exception. Like so:

import bpy

def a_function(context):
    raise Exception( "An error occured in 'a_function'" )

class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"

    @classmethod
    def poll(cls, context):
        return context.active_object is not None

    def execute(self, context):
        try:
            a_function( context )
        except Exception as e:
            raise Exception( *e.args, "from SimpleOperator" )

        return {'FINISHED'}

def register():
    bpy.utils.register_class(SimpleOperator)

def unregister():
    bpy.utils.unregister_class(SimpleOperator)

if __name__ == "__main__":
    register()

    # test call
    bpy.ops.object.simple_operator()

Answer 4

If you want to determine if the call is from code, use [self.options.is_invoke == True] is button call