model.py

import trimesh

class Model(Observable):
    def __init__(self, mesh=None):
        super(Model, self).__init__()
        self.mesh = mesh
        self.viewpoints = {}
        self.flightspaths = {}

    @property
    def mesh(self):
        return self._mesh

    @mesh.setter
    def mesh(self, mesh):
        if isinstance(mesh, Mesh):
            if self._mesh:
                [mesh.register(o) for o in self._mesh._observers]
                self._mesh.unregister_all()
            self._mesh = mesh
            self._mesh.update_observers()
        else:
            name = ""
            if self._mesh:
                name = self._mesh.name
            if isinstance(mesh, trimesh.Trimesh):
                self._mesh = Mesh(, name=name)


class Mesh(Observable, trimesh.Trimesh):
    def __init__(self, *args, **kwargs, name=""):
        super(Mesh, self).__init__(*args, **kwargs)
        self.name = name

class Observable(object):
    """ 
    Class that implements the observer pattern
    allows registering functions that are called on change
    """
    def __init__(self):
        self._observers = []
    def register(self, observer):
        """
        Register a callback function with the observable that gets called
        """
        if not observer in self._observers:
            self._observers.append(observer)

    def unregister(self, observer):
        """
        Unregister a callback previously registered with the observable
        """
        if observer in self._observers:
            self._observers.remove(observer)

    def unregister_all(self):
        """ 
        Unregister all observers
        """
        if self._observers:
            del self._observers[:]

    def update_observers(self, *args, **kwargs):
        """ 
        Notify all observers of a change
        """
        for observer in self._observers:
            observer(*args, **kwargs)