Définition des Constantes dans Django

Je veux avoir certaines constantes dans un Django Projets. Par exemple, disons une constante appelée MIN_TIME_TEST.

Je voudrais être en mesure d'accéder à cette constante dans deux endroits: à partir de l'intérieur de mon code Python, et à partir de n'importe quel des Modèles de.

Quelle est la meilleure façon de faire cela?

EDIT:
Pour clarifier, je sais à propos de Modèle de Contexte Processeurs et sur la juste mettre les choses en settings.py ou dans un autre fichier et simplement l'importation.

Ma question est, comment puis-je combiner les deux approches, sans violer le "Don't Repeat Yourself" règle? Sur la base des réponses jusqu'à présent, voici ma démarche:

J'aimerais créer un fichier appelé global_constants.py qui aura une liste de constantes (des choses comme MIN_TIME_TEST = 5). Je peux import ce fichier dans n'importe quel module pour obtenir les constantes.

Mais maintenant, je veux créer le contexte du processeur qui retourne l'ensemble de ces constantes. Comment puis-je faire cela automatiquement, sans avoir à les énumérer à nouveau dans un dictionnaire, comme dans Jean Mee réponse?

OriginalL'auteur Edan Maor | 2010-10-28

  1. 16

    Les deux Luper et Vladimir sont corrects à mon humble avis, mais vous aurez besoin des deux pour compléter vos exigences.

    • Bien que, les constantes ne pas besoin pour être dans la settings.py, vous pouvez les placer n'importe où et de les importer à partir de ce lieu dans votre vue/modèle/module de code. J'ai parfois de les mettre dans le __init__.py si je n'aime pas à avoir à être considérées comme pertinentes à l'échelle mondiale.

    • un contexte processeur comme ceci permettra de s'assurer que les variables sélectionnées sont globalement dans le modèle portée

      def settings(request):
    """
    Put selected settings variables into the default template context
    """
    from django.conf import settings
    return {
        'DOMAIN':     settings.DOMAIN,
        'GOOGLEMAPS_API_KEY': settings.GOOGLEMAPS_API_KEY,
    }

    Mais c'est peut-être exagéré si vous êtes nouveau à django, peut-être vous êtes juste demander comment mettre des variables dans le modèle de champ...?

    from django.conf import settings

...
# do stuff with settings.MIN_TIME_TEST as you wish

render_to_response("the_template.html", { 
    "MIN_TIME_TEST": settings.MIN_TIME_TEST 
}, context_instance=RequestContext(request)
    Merci, c'est en effet la direction que je veux aller. Mais s'il vous plaît voir mon clarification/autre question, à savoir comment puis-je faire ce que vous dites, sans avoir à énumérer toutes les constantes deux fois?
    Envelopper le tout dans un dictionnaire, puis mettre le dictionnaire dans son contexte. Vous pourrez y accéder via la notation point. par exemple: {{yourDict.yourConstant}}

    OriginalL'auteur John Mee

  2. 4

    De construire sur les réponses des autres, voici une façon simple que vous mettriez ce:

    Dans votre fichier de paramètres:

    GLOBAL_SETTINGS = {
    'MIN_TIME_TEST': 'blah',
    'RANDOM_GLOBAL_VAR': 'blah',
}

    Puis, profitant de Jean-Mee contexte du processeur:

    def settings(request):
    """
    Put selected settings variables into the default template context
    """
    from django.conf import settings
    return settings.GLOBAL_SETTINGS

    Cela permettra de résoudre le SEC problème.

    Ou, si vous ne prévoyez d'utiliser les paramètres globaux de temps en temps et envie de les appeler à partir de l'intérieur de la vue:

    def view_func(request):
    from django.conf import settings
    # function code here
    ctx = {} #context variables here
    ctx.update(settings.GLOBAL_SETTINGS)
    # whatever output you want here

    OriginalL'auteur Jordan Reiter

  3. 3

    Envisager de mettre en settings.py de votre application. Bien sûr, afin de l'utiliser dans le modèle, vous aurez besoin pour le rendre disponible à un modèle comme toute autre habitude variable.

    OriginalL'auteur devmiles.com

  4. 2

    Utilisation contexte processeurs avoir vos constantes disponibles dans tous les modèles (à l'settings.py est un endroit agréable pour les définir comme Vladimir a dit).

    Ce qui est une bonne façon de les ajouter dans le contexte des processeurs d'après les définir dans le settings.py? Je préfère ne pas avoir à répéter les noms de toutes les constantes fois de plus.
    Toutes les informations sont disponibles sur la page Luper Rouch liés. Vous devez créer une fonction python qui permet de renvoyer un dictionnaire de vars (c'est là que vous revenez à votre constantes) et la liste de votre fonction dans TEMPLATE_CONTEXT_PROCESSORS réglage.

    OriginalL'auteur Luper Rouch

  5. 1

    Contexte processeurs sont mieux adaptés à la manipulation d'objet dynamique des données--ils sont définis comme un mappage dans le la documentation et, dans de nombreux posts ici ils sont en cours de modification ou passé autour de points de vue--il n'est pas logique qu'un modèle peut perdre l'accès à l'information mondiale, parce que, par exemple, vous avez oublié d'utiliser spécialisée contexte du processeur dans la vue. Les données sont globales, par définition, & que les couples à la vue du modèle.

    Une meilleure façon est de définir un modèle personnalisé de la balise. De cette façon:

    • modèles ne sont pas en s'appuyant sur les points de vue à l'échelle de l'information adoptée en eux
    • SEC-er: l'application définir les paramètres globaux peuvent être exportés vers de nombreux projets, en éliminant le code commun à travers les projets de
    • modèles de décider s'ils ont accès à l'information, et non pas le point de vue des fonctions

    Dans l'exemple ci-dessous, j'ai traiter votre problème de chargement dans ce MIN_TIME_TEST variable, et un problème que j'ai souvent le visage, le chargement dans les Url que lorsque mon environnement change.

    J'ai 4 environnements--2 dev et 2 production:

    • Dev: django-serveur web, url: localhost:8000
    • Dev: serveur web apache: url: sandbox.com -> decide à l'adresse 127.0.0.1
    • Prod sandbox serveur, url: sandbox.domain.com
    • Prod serveur: url: domain.com

    Je le fais sur tous mes projets & garder toutes les url dans un fichier, global_settings.py il est donc accessible à partir du code. Je définir un modèle personnalisé de la balise {% site_url %} qui peuvent être (éventuellement) chargé dans n'importe quel modèle

    J'ai créer une application appelée global_settings, et assurez-vous qu'il est inclus dans mes paramètres.INSTALLED_APPS tuple.

    Django compile basé sur un modèle de texte dans des nœuds avec une méthode render() qui raconte comment les données doivent être affichées--j'ai créé un objet qui rend les données par returnning valeurs dans mon global_settings.py basé sur le nom passé en.

    Il ressemble à ceci:

    from django import template
import global_settings

class GlobalSettingNode(template.Node):
    def __init__(self, settingname):
        self.settingname = settingname;
    def render(self, context):
        if hasattr(global_settings, self.settingname):
            return getattr(global_settings, self.settingname)
        else:
            raise template.TemplateSyntaxError('%s tag does not exist' % self.settingname)

    Maintenant, dans global_settings.py -je m'inscrire à un couple tags: site_url pour mon exemple, et min_test_time pour votre exemple. De cette façon, lorsque {% min_time_test %} est appelé à partir d'un modèle, il va appeler get_min_time_test qui décide de charger dans la valeur=5. Dans mon exemple, {% site_url %} va faire un nom-fonction de recherche de sorte que je peux conserver tous les 4 Url définies à la fois et de choisir dans quel environnement j'utilise. C'est plus souple pour moi qu'à l'aide de Django reinhardt, construit dans les paramètres.Debug=True/False flag.

    from django import template
from templatenodes import GlobalSettingNode
register = template.Library()


MIN_TIME_TEST = 5

DEV_DJANGO_SITE_URL = 'http://localhost:8000/'
DEV_APACHE_SITE_URL = 'http://sandbox.com/'
PROD_SANDBOX_URL = 'http://sandbox.domain.com/'
PROD_URL = 'http://domain.com/'

CURRENT_ENVIRONMENT = 'DEV_DJANGO_SITE_URL'



def get_site_url(parser, token):
    return GlobalSettingNode(CURRENT_ENVIRONMENT)

def get_min_time_test(parser, token):
    return GlobalSettingNode('MIN_TIME_TEST')

register.tag('site_url', get_site_url)
register.tag('min_time_test', get_min_time_test)

    Noter que pour que cela fonctionne, django attend global_settings.py être situé dans un python emballés appelé templatetags sous votre Django app. Mon Django app est appelé ici global_settings, donc ma structure de répertoire ressemble à:

    /project-name/global_settings/templatetags/global_settings.py
    etc.

    Finalement, le modèle choisit de charger dans les paramètres globaux ou pas, ce qui est bénéfique pour la performance. Ajoutez cette ligne à votre modèle pour afficher tous les tags inscrits dans global_settings.py:

    {% load global_settings %}

    Maintenant, d'autres projets qui ont besoin d'MIN_TIME_TEST ou ces environnements exposés suffit d'installer cette application =)

    OriginalL'auteur Alan Illing

  6. 0

    Dans le contexte du processeur, vous pouvez utiliser quelque chose comme:

    import settings

context = {}
for item in dir(settings):
    #use some way to exclude __doc__, __name__, etc..
    if item[0:2] != '__':
        context[item] = getattr(settings, item)

    OriginalL'auteur andrei1089

  7. 0

    Variante sur Jean-Mee de la dernière partie, avec un peu d'élaboration sur la même idée de la Jordanie Reiter discute.

    Supposons que vous avez quelque chose dans vos paramètres apparente à ce que la Jordanie a proposé, en d'autres termes, quelque chose comme:

    GLOBAL_SETTINGS = {
   'SOME_CONST': 'thingy',
   'SOME_OTHER_CONST': 'other_thingy',
}

    Supposons, en outre, vous disposez déjà d'un dictionnaire avec certaines des variables que vous souhaitez passer votre modèle, peut-être passés comme arguments à votre vue. Appelons ça de la my_dict. Supposons que vous voulez les valeurs dans my_dict pour remplacer ceux de la settings.GLOBAL_SETTINGS dictionnaire.

    Vous pourriez faire quelque chose de votre point de vue comme:

    def my_view(request, *args, **kwargs)
    from django.conf import settings
    my_dict = some_kind_of_arg_parsing(*args,**kwargs)
    tmp = settings.GLOBAL_SETTINGS.copy()
    tmp.update(my_dict)
    my_dict = tmp
    render_to_response('the_template.html', my_dict, context_instance=RequestContext(request))

    Cela vous permet d'avoir les paramètres déterminés à l'échelle mondiale, à la disposition de vos modèles, et ne vous obligent pas à taper manuellement chacun d'entre eux.

    Si vous ne pas avez d'autres variables à passer le modèle, ni aucune nécessité de les remplacer, il vous suffit de faire:

    render_to_response('the_template.html', settings.GLOBAL_SETTINGS, context_instance=RequestContext(request))

    La principale différence entre ce que je suis en train de parler ici & ce que la Jordanie a, c'est que pour sa, settings.GLOBAL_SETTINGS remplace tout ce qu'il peut avoir en commun w/votre contexte dictionnaire, et avec le mien, mon contexte dictionnaire remplace settings.GLOBAL_SETTINGS. YMMV.

    OriginalL'auteur desfido