J'ai essayé de toucher le framework Web Python Pyramid. Cet article est un mémorandum se concentrant sur des choses qui sont susceptibles de se faire prendre, telles que "Alors que faire lors de la mise en œuvre réelle", en omettant les bases de "J'ai essayé de l'installer".
En plus de l'envoi d'URL familier, Pyramid dispose d'une méthode de mappage d'URL appelée Traversal.
En ce qui concerne la traversée, seules les choses conceptuelles sont décrites dans l'explication du site anglais original, et même si vous recherchez le vaste réseau, il y a plusieurs descriptions, mais il semble que l'interprétation (?) Est différente pour chacun, et la méthode de mise en œuvre est Faux.
Cependant, pour mettre en œuvre le contrôle d'accès, il semble que la traversée doive être utilisée comme dans l'exemple du site d'origine, et tant que le site est créé avec Pyramid, cela ne peut être évité.
Puisque le concept de traversée est décrit dans la famille head, l'explication détaillée est omise, mais en termes simples, chaque élément de l'URL est considéré comme la valeur clé du dictionnaire Python imbriqué, et la dernière clé restante est le nom de la vue et la dernière. Il s'agit d'une méthode de mappage d'URL dans laquelle l'élément qui frappe est le contexte (cible de l'opération).
Par exemple, si l'URL permettant de modifier les informations utilisateur du compte "testutilisateur" d'un site est "http://example.com/account/testuser/edit", en traversée
-- Root ['account'] ['testuser'] L'élément obtenu par `` `est une ressource --edit``` est le nom de la vue
Sera. La racine ci-dessus est décrite par commodité, mais c'est en fait l'élément de départ de la traversée et c'est une ressource générée chaque fois qu'il y a une demande de l'utilisateur. Il y a une erreur, mais http://example.com peut être considéré comme la ressource racine de ce site.
Pour le résumer correctement, il est écrit comme ci-dessus, mais il frappe le mur immédiatement.
Le contenu ci-dessus est déjà décrit (bien qu'en anglais) sur le site Web d'origine. Si vous prenez le site d'origine comme une hirondelle, la mise en œuvre des ressources liées aux comptes utilisateurs sera la suivante.
def site_root_factory(request):
root = dict()
root['account'] = dict()
root['account']['testuser'] = request.dbsession.Query(User).filter(name = 'testuser').first()
Quant à Atari Mae, on ne peut pas dire qu'il s'agit d'une implémentation. Même s'il s'agit d'un site fixe, il est naturel que le compte utilisateur puisse être «enregistré» / «supprimé», et il n'en est pas toujours un, par exemple, que se passe-t-il si «surfeur» est ajouté?
En d'autres termes, si vous souhaitez créer un site Web transversal et dynamique, vous ne pouvez pas simplement implémenter la ressource en tant que dictionnaire Python et ses éléments.
Une ressource n'est pas simplement un'dictionary `dict () '` , mais une classe / objet qui implémente la méthode`` getitem. Si ce n'est pas écrit, ce sera difficile pour les débutants. getitem```Qu'Est-ce que c'est? C'est la preuve que vous n'avez pas lu la documentation originale de python, vous devriez donc la lire maintenant.
En utilisant l'exemple ci-dessus, l'élément obtenu par la clé'account'peut être implémenté comme la classe AccountFactory suivante qui implémente `` `__ getitem__```.
class AccountResource(object):
def __init__(self, parent, request, model):
self.request = request
self.model = model
self.parent = parent
@property
def __name__(self):
return self.model.name
@property
def __parent__(self):
return self.parent
class AccountFactory(object):
def __init__(self, parent, request):
self.request = request
self.parent = parent
@property
def __name__(self):
return 'account'
@property
def __parent__(self):
return self.parent
def __getitem__(self, key):
m = self.request.dbsession.Query(User).filter(name = key).first()
if m:
reurn m
else:
raise KeyError(key)
def site_root_factory(request):
root = dict()
root['account'] = AccountFactory(root, request)
Maintenant, lorsque `root ['account'] ['testuser']` est appelé, la méthode __ getitem__ de ʻAccountFactory sera` `` `key = 'testuser Appelé avec', le modèle User sera désormais appelé comme contexte final.
Pour définir une vue d'édition qui manipule ce contexte (modèle utilisateur), par exemple:
@view_config(name='edit', context='User', renderer='editview.jinja2')
def edit(context, request)
#context est le modèle utilisateur obtenu à la suite de la traversée
#Le processus de fonctionnement du modèle utilisateur est décrit ci-dessous.
Pour une raison quelconque, il n'y avait pas d'exemple de traversée lorsque l'accès à la base de données s'est produit comme dans l'exemple ci-dessus, il est donc décrit ici.
Il n'y a presque pas de littérature japonaise. Je devine.
Même s'il y a une installation Pyramid de routine et un article "Commencé!". Que diriez-vous du fait qu'il n'y a qu'une seule chose ici à l'époque où vous pouvez l'installer rapidement avec pip? Je pense, mais que dois-je faire avec l'article sur la méthode d'installation tel que décrit sur le site d'origine?
Recommended Posts