__init__.py

bl_info = {
    'name': 'Render Webhook',
    'author': 'vignedev',
    'version': (1, 0, 1),
    'blender': (4, 2, 0),
    'description': 'Sends a message after render events to a webhook',
    'category': 'Render'
}

import bpy
import json
import requests
import datetime
from bpy.types import Operator, AddonPreferences, Scene, PropertyGroup, Panel
from bpy.props import BoolProperty, StringProperty

####################################################################################################

class RenderWebhook_TestOperator(Operator):
    bl_idname = 'render.webhook_test'
    bl_label = 'Send a test message to saved webhook'

    def execute(self, context):
        if RenderWebhook_Execute(context.scene, 'TestOperator'):
            return {'FINISHED'}
        
        self.report({'WARNING'}, 'Failed to send the Webhook. Check the console for further information.')
        return {'CANCELLED'}

class RenderWebhook_Prefs(AddonPreferences):
    bl_idname = __name__
    webhook_url: StringProperty(
        name='Webhook URL',
        description='URL to a webhook endpoint'
    )
    webhook_type: bpy.props.EnumProperty(
        name='Webhook Type',
        items=[
            ('DISCORD', 'Discord', 'Message is sent as a Discord Embed'),
            ('SLACK', 'Slack', 'Message is sent in text form'),
        ],
        default='DISCORD'
    )
    
    def draw(self, context):
        layout = self.layout
        if not bpy.app.online_access:
            box = layout.box()
            box.label(text='Online Access is not enabled in Blender!', icon='ERROR')

        layout.prop(self, 'webhook_url')
        layout.prop(self, 'webhook_type')
        layout.operator('render.webhook_test')

class RenderWebhook_Settings(PropertyGroup):
    enable_webhook: BoolProperty(
        name='Enable Render Webhook',
        description='Hook up the webhook to the render_complete handler.',
        default=False
    )

    enable_webhook_render_cancel: BoolProperty(
        name='render_cancel',
        description='...on canceling a render job',
        default=True
    )
    enable_webhook_render_complete: BoolProperty(
        name='render_complete',
        description='...on completion of render job',
        default=True
    )
    enable_webhook_render_init: BoolProperty(
        name='render_init',
        description='...on initialization of a render job',
        default=True
    )
    enable_webhook_render_post: BoolProperty(
        name='render_post',
        description='...on render (after)',
        default=False
    )
    enable_webhook_render_pre: BoolProperty(
        name='render_pre',
        description='...on render (before)',
        default=False
    )
    enable_webhook_render_stats: BoolProperty(
        name='render_stats',
        description='...on printing render statistics',
        default=False
    )
    enable_webhook_render_write: BoolProperty(
        name='render_write',
        description='...on writing a render frame (directly after the frame is written)',
        default=False
    )

class RenderWebhook_Panel(Panel):
    bl_label = 'Render Webhook'
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = 'output'
    bl_options = {'DEFAULT_CLOSED'}
    bl_idname = 'RENDERWEBHOOK_PT_OUTPUT'

    def draw_header(self, context):
        self.layout.prop(context.scene.render_webhook_settings, 'enable_webhook', text='')

    def draw(self, context):
        self.layout.label(text='Execute on these events:')
        box = self.layout.box()
        box.enabled = context.scene.render_webhook_settings.enable_webhook

        box.prop(context.scene.render_webhook_settings, 'enable_webhook_render_cancel',   text='On Render Job Cancelled')
        box.prop(context.scene.render_webhook_settings, 'enable_webhook_render_complete', text='On Render Job Completed')
        box.prop(context.scene.render_webhook_settings, 'enable_webhook_render_init',     text='On Render Job started')
        box.prop(context.scene.render_webhook_settings, 'enable_webhook_render_post',     text='After rendering a frame')
        box.prop(context.scene.render_webhook_settings, 'enable_webhook_render_pre',      text='Before rendering a frame')
        box.prop(context.scene.render_webhook_settings, 'enable_webhook_render_stats',    text='After Render Statistics')
        box.prop(context.scene.render_webhook_settings, 'enable_webhook_render_write',    text='After Render Frame Written')

def RenderWebhook_Execute(scene: Scene, event_name: str) -> bool:
    if not bpy.app.online_access:
        print('bpy.app.online_access is set to False')
        return False

    pref: RenderWebhook_Prefs = bpy.context.preferences.addons[__name__].preferences
    blendname = bpy.data.filepath or 'no name'

    payload: dict
    if pref.webhook_type == 'DISCORD':
        payload = {
            'content': None,
            'embeds': [
                {
                    'title': f'`{event_name}`',
                    'color': 15110425,
                    'timestamp': datetime.datetime.now().isoformat(),
                    'footer': {
                        'text': scene.name
                    },
                    'fields': [
                        {
                            'name': 'File',
                            'value': blendname,
                            'inline': False
                        }
                    ]
                }
            ]
        }
    elif pref.webhook_type == 'SLACK':
        payload = {
            'text': f'**Event**: `{event_name}` ({datetime.datetime.now().isoformat()})\n'
                    f'**Scene**: `{scene.name}`\n'
                    f'**File**: `{blendname}`\n'
        }
    

    try:
        requests.post(
            pref.webhook_url,
            data=json.dumps(payload),
            headers={'Content-Type': 'application/json'}
        )
    except Exception as ex:
        print(ex)
        return False

    return True

####################################################################################################

@bpy.app.handlers.persistent
def RenderWebhook_Callback_render_cancel(_):
    scene = bpy.context.scene
    settings = scene.render_webhook_settings
    if settings.enable_webhook and settings.enable_webhook_render_cancel:
        RenderWebhook_Execute(scene, 'render_cancel')
    
@bpy.app.handlers.persistent
def RenderWebhook_Callback_render_complete(_):
    scene = bpy.context.scene
    settings = scene.render_webhook_settings
    if settings.enable_webhook and settings.enable_webhook_render_complete:
        RenderWebhook_Execute(scene, 'render_complete')
    
@bpy.app.handlers.persistent
def RenderWebhook_Callback_render_init(_):
    scene = bpy.context.scene
    settings = scene.render_webhook_settings
    if settings.enable_webhook and settings.enable_webhook_render_init:
        RenderWebhook_Execute(scene, 'render_init')
    
@bpy.app.handlers.persistent
def RenderWebhook_Callback_render_post(_):
    scene = bpy.context.scene
    settings = scene.render_webhook_settings
    if settings.enable_webhook and settings.enable_webhook_render_post:
        RenderWebhook_Execute(scene, 'render_post')
    
@bpy.app.handlers.persistent
def RenderWebhook_Callback_render_pre(_):
    scene = bpy.context.scene
    settings = scene.render_webhook_settings
    if settings.enable_webhook and settings.enable_webhook_render_pre:
        RenderWebhook_Execute(scene, 'render_pre')
    
@bpy.app.handlers.persistent
def RenderWebhook_Callback_render_stats(_):
    scene = bpy.context.scene
    settings = scene.render_webhook_settings
    if settings.enable_webhook and settings.enable_webhook_render_stats:
        RenderWebhook_Execute(scene, 'render_stats')
    
@bpy.app.handlers.persistent
def RenderWebhook_Callback_render_write(_):
    scene = bpy.context.scene
    settings = scene.render_webhook_settings
    if settings.enable_webhook and settings.enable_webhook_render_write:
        RenderWebhook_Execute(scene, 'render_write')

####################################################################################################

def register():
    bpy.utils.register_class(RenderWebhook_Prefs)
    bpy.utils.register_class(RenderWebhook_Settings)
    bpy.utils.register_class(RenderWebhook_TestOperator)
    bpy.utils.register_class(RenderWebhook_Panel)
    bpy.types.Scene.render_webhook_settings = bpy.props.PointerProperty(type=RenderWebhook_Settings)

    bpy.app.handlers.render_cancel.append(RenderWebhook_Callback_render_cancel)
    bpy.app.handlers.render_complete.append(RenderWebhook_Callback_render_complete)
    bpy.app.handlers.render_init.append(RenderWebhook_Callback_render_init)
    bpy.app.handlers.render_post.append(RenderWebhook_Callback_render_post)
    bpy.app.handlers.render_pre.append(RenderWebhook_Callback_render_pre)
    bpy.app.handlers.render_stats.append(RenderWebhook_Callback_render_stats)
    bpy.app.handlers.render_write.append(RenderWebhook_Callback_render_write)

def unregister():
    bpy.utils.unregister_class(RenderWebhook_Prefs)
    bpy.utils.unregister_class(RenderWebhook_Settings)
    bpy.utils.unregister_class(RenderWebhook_TestOperator)
    bpy.utils.unregister_class(RenderWebhook_Panel)
    del bpy.types.Scene.render_webhook_settings

    bpy.app.handlers.render_cancel.remove(RenderWebhook_Callback_render_cancel)
    bpy.app.handlers.render_complete.remove(RenderWebhook_Callback_render_complete)
    bpy.app.handlers.render_init.remove(RenderWebhook_Callback_render_init)
    bpy.app.handlers.render_post.remove(RenderWebhook_Callback_render_post)
    bpy.app.handlers.render_pre.remove(RenderWebhook_Callback_render_pre)
    bpy.app.handlers.render_stats.remove(RenderWebhook_Callback_render_stats)
    bpy.app.handlers.render_write.remove(RenderWebhook_Callback_render_write)

if __name__ == '__main__':
    register()