Вызов функции в классе из другого класса

Есть несколько способов сделать это, но это больше вопрос о Python, чем о BPY API.

Один метод

Большую часть времени, если у меня есть функциональность, которая разделяется между операторами, я буду брать их из класса и ссылаться на них в операторах.

def some_shared_function(caller, context):
    # ...
    return 

class A(bpy.types.Operator):
    (...)
    def execute(self,context):
        some_shared_function(self, context)

class B(bpy.types.Operator):
    (...)
    def execute(self,context):
        # other code here
        some_shared_function(self, context)

Другой метод

Или заставить оператора вести себя по-разному в зависимости от передаваемых параметров

class AB(bpy.types.Operator):
    bl_idname = "wm.simple_multi_operator"
    bl_label = "Multi Purpose Operator"

    param_one = StringProperty()
    # param_two = StringProperty()

    def execute(self,context):

        if self.param_one == 'A':
            self.some_functionality(context)

        elif self.param_one == 'B':
            # some other code
            self.some_functionality(context)

        return {'FINISHED'}

    def some_functionality(self, context):
        ...

В коде пользовательского интерфейса вы передадите такие параметры, как это

row = layout.row()
opname = "wm.simple_multi_operator"
row.operator(opname, text='A').param_one = 'A'
row.operator(opname, text='B').param_one = 'B'

# if you have more than one property for the operator
op_two = row.operator(opname, text='B / Mode Y')
op_two.param_one = 'B'
op_two.param_two = 'Mode Y'

Вызов оператора из скрипта напрямую работает следующим образом

# or calling from a script
bpy.ops.wm.simple_multi_operator(param_one='A')
bpy.ops.wm.simple_multi_operator(param_one='B')

# with more than one parameter pass the keywords and values
bpy.ops.wm.simple_multi_operator(param_one='B', param_two='Mode Y')

Плюсы и минусы этого метода заслуживают упоминания.

• con: если вы привыкли создавать подсказки для своих операторов, этот подход не позволяет вам определить уникальную подсказку для кнопок.
• pro: вы можете быстро предоставить оператору новую функциональность без объявления целого нового оператора

Другой метод (с использованием класса Pythonmethod декоратор)

import bpy


class A(bpy.types.Operator):
    bl_idname = "object.simple_operator_a"
    bl_label = "Simple Object Operator A"

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

    @classmethod
    def some_function(cls, some_parameter='not woop'):
        print('some_parameter', some_parameter)

class B(bpy.types.Operator):
    bl_idname = "object.simple_operator_b"
    bl_label = "Simple Object Operator B"

    def execute(self,context):
        A.some_function('woooop')
        return {'FINISHED'}


def register():
    bpy.utils.register_module(__name__)


def unregister():
    bpy.utils.unregister_module(__name__)


if __name__ == "__main__":
    register()

Затем вызывая их:

>>> bpy.ops.object.simple_operator_a()
some_parameter not woop
{'FINISHED'}

>>> bpy.ops.object.simple_operator_b()
some_parameter woooop
{'FINISHED'}

Не уверен, что это полезно, но добавляю для полноты картины:

# autocomplete from the open parenthesis gives:
>>> bpy.types.OBJECT_OT_simple_operator_a.some_function(
some_function(cls, some_parameter='not woop')

# calling the function, gives:
>>> bpy.types.OBJECT_OT_simple_operator_a.some_function()
some_parameter not woop