Quanto uma visão deve saber sobre o modelo?

Estou criando um aplicativo em python com um wrapper python para WPF e com suporte ao DAG. Atualmente, estou em um ponto em que preciso decidir uma maneira consistente de interagir entre os dados e a exibição.

Tanto quanto vejo, atualmente existem duas soluções óbvias.

O primeiro é semelhante ao modo como os aplicativos Android são estruturados. Você tem um controlador que define / preenche a exibição. Portanto, o controlador possui a visualização e envia apenas os dados primitivos que serão exibidos. A visualização é apenas uma camada idiota e não tem idéia do que está acontecendo e de onde são esses dados. E então, se o usuário interagir com a visualização, ele enviará retornos de chamada para o controlador (se registrado).

UserInfoController.py

userInfoView = UserInfoView()
userInfoView.onGenderChangedCallback = self.onGenderChangedCallback 
userInfoView.setUserGenderValue(user.getGender())

UserInfoView.py

def setUserGenderValue(self, gender):
    self.userGender = gender

def getView(self):
    return ui.Label(self.userGender, onEditCallback=self.onGenderChangedCallback)

O segundo é passar um modelo (referência de) para a visualização e permitir que a visualização recupere e atualize os dados. A visualização agora contém o modelo e, portanto, pode atualizá-lo sem nenhum retorno de chamada adicional para o controlador.

UserInfoViewModel.py

self.gender = 'Male'

UserInfoView.py

def getView(self):
    return ui.Label(self.ViewModel().getGender(), onEdited=self.genderEdited)

def genderEdited(self, newValue):
    self.ViewModel().setGender(newValue)

Então, eu acho que o que estou perguntando é: devo passar os dados muito primitivos e manter a visão o mais genérica possível, trabalhar com retornos de chamada e fazer as especificações comerciais no controlador.

Ou devo passar o modelo inteiro para a visualização e permitir que a visualização atualize o modelo diretamente. Isso significa que haverá menos código para digitar.

PS. Não julgue o código - é apenas para visualização.

EDITAR:

Também para adicionar - este aplicativo será escrito em python, que suporta tipagem de patos. Isso significa que, com a segunda abordagem, a visualização ainda é reutilizável, desde que o modelo atenda à interface necessária.

A única "lógica" que uma exibição deve conter deve ser o código responsável por alterar o estado visível da GUI para o usuário. Qualquer código que manipule dados ou calcule um valor deve ser tratado em outro lugar.

Sua visão deve saber como é o modelo, mas deve ignorar o comportamento associado a qualquer coisa que o modelo exponha.

A passagem de tipos de dados simples para sua visualização o torna responsável por manipular a GUI e armazenar o estado da visualização, o que pode facilmente se tornar pesado.

Você deve passar o modelo diretamente para a vista, se o modelo for construído para manipulação pela vista. Se o seu modelo for o mesmo usado pelo mecanismo de armazenamento de dados, isso poderá causar problemas mais adiante se a representação interna e a representação da exibição divergirem (como costuma acontecer).

Basicamente, você deve apenas ter um View, View Model, Data Model e algo para lidar com a lógica de negócios. Então todas as suas preocupações são facilmente separadas, você apenas precisa colá-las.

Essa é uma resposta generalizada, mas a visão da IMO deve fazer a menor quantidade de trabalho possível (por exemplo, validar entradas do usuário).

Dessa forma, você pode esperar que toda a sua lógica esteja no controlador. Isso facilita muito a manutenção no caminho, princípio de responsabilidade única e tudo mais.