Flask - dobre praktyki widoki i modele

Mam nadzieję że tego nie zagmatwam i moje pytanie zostanie dobrze zrozumiane. Załóżmy że mamy aplikację we flasku która ma zdefiniowane 4 modele, A, B, C, D. Jak podchodzicie do organizacji tych modeli jeśli chodzi o CRUD. Dla każdego z nich z osobna tworzycie widoki typu 'createNew', 'update', 'delete' itp.? Czy może tworzycie jakieś uniwersalne 'class view' i tylko rejestrujcie dla nich każdy model z osobna? Zaznaczam że nie chodzi mi tu o budowanie rest api.

Wersja 0.12 wprowadziła tzw. Pluggable Views, gdzie zamiast funkcji wykorzystuje się klasy. Celem wprowadzenia tej funkcjonalności była chęć umożliwiania utworzenia widoku, którego część można zmienić i dostosować do obsługi kilku modeli.

Dokładnie o to mi chodzi, testuje trochę tą formę ale powiem szczerze że mało jest przykładów które by pokazały dobre praktyki (a w dokumentacji jest w zasadzie przedstawiony jedynie koncept z prostym przykładem).

Weźmy dla przykładu podejście "klasyczne" we flasku Z modelem Category i formularzem do jego obsługi:

@app.route('/admin/add/category', methods=['GET', 'POST'])
def addCategory():
    form = AddCategoryForm(request.form)
    if request.method == 'POST' and form.validate_on_submit():
        obj = Category(name=form.name.data,
                       active=form.active.data,
                       cid=form.cid.data)
        db.session.add(obj)
        db.session.commit()
        flash('new category added')
        return redirect(url_for('settings'))
    return render_template('addcategory.html', form=form)

A teraz z użyciem pluggabble view (czyli class view), które robi dokładnie to samo ale jest bardziej "uniwersalne":

class AddNew(View):
    def __init__(self, form, template_name):
        self.form = form
        self.template_name = template_name
    
    def dispatch_request(self):
        f = self.form(request.form)
        if request.method == 'POST' and f.validate_on_submit():

            if self.form == AddCategoryForm:
                obj = Category(name=f.name.data,
                       active=f.active.data,
                       cid=f.cid.data)
                
            db.session.add(obj)
            db.session.commit()
            print("db update")
            return redirect(url_for('settings'))
        return render_template(self.template_name, form=f)

app.add_url_rule("/add/category", methods=['POST', 'GET'], view_func=AddNew.as_view(
    'add_category', 
    form = AddCategoryForm, 
    template_name = 'addcategory.html'
))

Co właściwie zyskuje dzięki temu? Bo w moim odczuciu podpinając więcej modeli pod taki widok tworzymy małego potworka. Polepsza nam się czytelność kodu? Zmniejszamy liczbę niepotrzebnych powtórzeń tych samych funkcji? Czy zmniejszamy liczbę linijek kodu? Średnio to wygląda.

Nie, nie tworzysz potworków do wszystkiego. Tworzysz klasę gdzie umieszczasz wspólne metody, a następnie dziedziczysz po tej klasie i dopiero te nowe klasy, które dziedziczą po tej bazowej modyfikujesz i dostosowujesz do konkretnego modelu.

Dlatego pytam na forum, poważnie ciężko o dobre przykłady pracy z pluggable view, te co są pokazne w dokumentacji czy jakiś tutorialowych przykładach są zbyt trywialne i nie przedstawiają większej złożoności. Nawet na gihubie przeglądając repozytoria nie można definitywnie stwierdzić jaka jest powszechna praktyka. Ja mam w tym momencie faktycznie problem jeśli chodzi o ocenę czy powinienem w danym momencie trzymać klasycznego podejścia czy korzystać z klas, i jak z nich korzystać do budowania lepszych widoków.

Pluggable Views nie zostały wprowadzone jako ciekawostka, tylko po to żeby z nich korzystać. Od kiedy w Django wprowadzili generic views to korzystam wyłącznie z nich i ciężko mi sobie teraz wyobrazić kodowanie bez tego. Jeżeli brakuje przykładów to może poszukaj przykładów w Django, które jest dużo bardziej popularne.