I'm looking for the Python function (if it exists at all) that saves the .blend file in order to modify it. If it doesn't exist - Please continue reading. I'm opened to any suggestions!


I want to expand it so that every time a .blend file is being saved, a Statistics.txt file with project info is saved along with it.


I think the whole thing is written in C instead of Python so I can't really modify it. The workaround I came up with is every time the wm.save_mainfile() or the wm.save_as_mainfile() is being called, a custom function gets called instead. That custom function simply runs the wm.save_mainfile() and then executes the code for the Stats.txt file.


The reason I want to avoid the workaround I came up with is that this method requires modifying a number of (5-10) .py files that actually run the wm.save_mainfile() function


So, thanks to @brockmann I got my hands on this example file (written by brockmann):

import bpy
import os
from bpy.app.handlers import persistent

bl_info = {
    "name": "Stats Add-on",
    "author": "brockmann",
    "version": (0, 1),
    "blender": (2, 82, 0),
    "category": "System"

class STATS_AP_preferences(bpy.types.AddonPreferences):
    # this must match the add-on name, use '__package__'
    # when defining this in a submodule of a python package.
    bl_idname = __name__

    state: bpy.props.EnumProperty(
        default = 'ON',
            ("ON", "on", "", 1),
            ("OFF", "off", "", 2)))

    def draw(self, context):
        layout = self.layout
        layout.prop(self, "state", expand=True)

class STATS_PT_panel(bpy.types.Panel):
    """Creates a Panel in the scene context of the properties editor"""
    bl_label = "Layout Demo"
    bl_idname = "SCENE_PT_layout"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "scene"

    def draw(self, context):
        layout = self.layout
        prefs = context.preferences.addons[__name__].preferences
        layout.prop(prefs, "state", expand=True)

def my_save_handler(dummy):
    if bpy.context.preferences.addons[__name__].preferences.state == 'ON':
        stats = bpy.context.scene.statistics(bpy.context.view_layer).split("|")
        text_file = os.path.join(bpy.path.abspath("//"), "stats.txt")
        with open(text_file, mode='wt', encoding='utf-8') as myfile:

classes = (

def register():
    from bpy.utils import register_class
    for cls in classes:


def unregister():
    from bpy.utils import unregister_class
    for cls in reversed(classes):

if __name__ == "__main__":

[The new problem]

Everything works great when I load the script and then save the project file after that. The problem is that after closing Blender and opening it some time later - the script no longer works for some reason, even though it's "ON". Any ideas why this is happening?


Everything works great! I updated the code snipet above so that anyone could use this tamplate. Thanks again to @brockmann !


You can use application handlers, specifically save_post or save_pre handlers. When you're saving the file, the handler kicks in and allows to execute whatever you want after/before saving the file:

import bpy
import os

def my_save_handler(dummy):
    stats = bpy.context.scene.statistics(bpy.context.view_layer).split("|")
    text_file = os.path.join(bpy.path.abspath("//"), "stats.txt")
    with open(text_file, mode='wt', encoding='utf-8') as myfile:

def register():

def unregister():

if __name__ == "__main__":

Demo above creates a file called stats.txt when saving the blend file:

Scene Collection 
 Memory: 593.1 MiB 

Handlers are freed when loading new files by default. If you want to keep the handler alive when loading new files add the @persistent decorator to the handler function:

def my_save_handler(dummy):

Further reading: https://docs.blender.org/api/current/bpy.app.handlers.html?highlight=save_pre#persistent-handler-example


Use the handlers.

There are two handlers available, save_pre and save_post. All handlers have two arguments, the scene and the depsgraph. Since the load and save handlers are not specific to one scene, rather all, any or all of these arguments can be None, the case here. The scene argument is often named dummy in examples when this is the case

The persistent decorator @persistent is used to keep the handler alive, should the user load a file.

Instead will iterate over all scenes and print the statistics on save.

import bpy

from bpy.app.handlers import persistent, save_post

def stats():
    from pathlib import Path
    fp = Path(bpy.data.filepath)
    name = fp.stem
    fp = fp.parent / f"{name}_stats.txt"
    buffer = [name]
    for scene in bpy.data.scenes:
                f"\t{ob.name} : {ob.type}"
                for ob in scene.objects

def save_handler(scene, depsgraph):


Note: tried looping over scenes and producing scene stats with scene.statistics(scene.view_layers[i]) as also outlined in @brockmann's excellent answer. (added example file IO using pathlib) As a general rule I suggest never mix context with handlers... especially operator calls. A detailed stats report can be gleaned from the data

Printing a hierarchy of objects.

Finding Vertices, Edges, Faces, and Tris using Python

Sample output, blend file snork.blend


    Armature : ARMATURE
    Cube : MESH
    Lamp : LIGHT
    Camera : CAMERA
    Cube.001 : MESH
    Cube.002 : MESH

Re pre and post.

If we make a handler for both, and simply

def save_pre_handler(dummy):
    print("PRE", bpy.data.filepath)

def save_post_handler(dummy):
    print("POST", bpy.data.filepath)

On opening snork.blend and save,

Read blend: /home/batfinger/Desktop/snork.blend
PRE /home/batfinger/Desktop/snork.blend
POST /home/batfinger/Desktop/snork.blend
Info: Saved "snork.blend"

then save as grunt.blend

PRE /home/batfinger/Desktop/snork.blend
POST /home/batfinger/Desktop/grunt.blend

could generate some report (make buffer global for example) from pre handler to use in post to inform grunt was previously snork.

Stat the file.

There is a python script available to read data from blend files without launching blender.

How to extract render info from a .blend file without launching Blender?

Is there a way to acces external .blend file's data with python script?

How to search through multiple Blender files to find a specific object?

Iterate over CollectionProperty with blendfile.py

Manipulating .blend file text blocks with blendfile.py (CRUD)

also mentioned in links is running blender in background mode

blender -b snork.py -P stats.py

Instead of writing file on save, could add a python or shell script to generate the info from a saved blend file.

blendstats snork.py
  • 2
    $\begingroup$ Very nice...... 30 seconds Mr. Holmes :D $\endgroup$
    – brockmann
    Sep 9 at 8:37
  • $\begingroup$ Works in this case and is a simple demo, OP messing around with a cool C binary anyway. If you have any serious concerns, don't hesitate and suggest an edit @batFINGER. $\endgroup$
    – brockmann
    Sep 9 at 8:54
  • 1
    $\begingroup$ Gotta do something to keep up brockers.. $\endgroup$
    – batFINGER
    Sep 9 at 10:44

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.