Suite

Est-il possible de créer des modèles d'impression en 2.6 et 2.8 ?

Est-il possible de créer des modèles d'impression en 2.6 et 2.8 ?


Est-ce possible? Je ne trouve que l'option "Ajouter des éléments à partir du modèle". Lorsque vous utilisez cette option, la mise en page par défaut est A4 paysage et vous devez modifier manuellement ces paramètres à l'aide de l'onglet de composition dans le composeur d'impression.

Les versions 2.4 et antérieures n'avaient pas besoin de cette étape supplémentaire. L'application d'un composeur d'impression préenregistré non seulement chargé dans tous les objets précédemment enregistrés dans le modèle, mais également répliqué la mise en page

Est-ce que j'ai raté quelque chose de vraiment évident ?


Vous devriez pouvoir en créer un directement à partir d'un modèle à l'aide du gestionnaire de composition.

Projet>Compositeur Manager…

Vous pouvez y ajouter un nouveau compositeur d'impression basé sur un modèle spécifique.


Tous les éléments d'un projet sont consolidés dans le package de projet ( .ppkx ), y compris les cartes et les vues 3D, les données et les couches dans les cartes, les boîtes à outils, les éléments d'historique de géotraitement, les styles, les mises en page et les dossiers ou connexions (serveur, workflow et ainsi de suite) le cas échéant.

Les packages de projet, par défaut, sont créés pour un usage interne. Le paramètre Partager en dehors de l'organisation vous permet de contrôler si un package doit être créé pour une utilisation interne (à l'intérieur du réseau de votre organisation) ou externe. Lorsque Partager en dehors de l'organisation est coché, les couches de géodatabase d'entreprise et les données référencées à partir d'un chemin UNC seront incluses dans le package de projet.

Les sources de données doivent être référencées à partir d'une géodatabase d'entreprise ou d'un chemin de fichier UNC pour créer un package interne dans lequel les données restent référencées. Les chemins de données locaux seront toujours consolidés et empaquetés. La création d'un package interne où les données sont uniquement référencées s'ouvrira avec des liens rompus s'ils sont partagés en dehors de votre environnement ou avec des collègues qui n'ont accès ni à la géodatabase d'entreprise ni aux partages de données UNC.

Les modèles peuvent être créés à l'aide du paramètre Package comme modèle. Un modèle de projet (fichier .aptx) peut vous aider à créer un nouveau projet en définissant des couches, des cartes et des données ainsi que les connexions requises.

Les boîtes à outils qui font partie d'un projet sont analysées à l'aide de l'outil Analyze Tools for Pro avant que le processus de consolidation ne soit effectué. Les erreurs identifiées arrêteront le processus de consolidation. Vous devrez soit corriger ces erreurs, soit supprimer l'outil du projet. Les données d'entrée utilisées par l'outil seront consolidées, qu'elles fassent ou non partie d'une carte du projet. Les boîtes à outils peuvent être exclues du package de projet de sortie en décochant le paramètre Inclure les boîtes à outils.

À l'instar des boîtes à outils de projet, l'historique du géotraitement (les informations de résultat de l'exécution d'un outil de géotraitement) sera inclus dans le package. Les données requises pour exécuter l'élément d'historique seront incluses dans le package de sortie, qu'elles existent ou non dans une carte ou une scène. Tout élément de l'historique non valide (échec lors de l'exécution) ou pour lequel les données sont introuvables entraînera l'arrêt du processus d'empaquetage. Vous devrez supprimer ou corriger l'élément d'historique en question. Les éléments de l'historique peuvent être exclus d'un package de projet en décochant le paramètre Inclure les éléments de l'historique.

Les connexions, telles que le dossier, le serveur, la base de données et le flux de travail, ne seront incluses que dans un package interne. Ces éléments sont supprimés si le package est créé pour être partagé en dehors de votre organisation.

Les éléments tels que les pièces jointes, les styles et les tâches seront référencés pour les packages internes s'ils faisaient partie du projet à partir d'un chemin UNC. Ces articles seront copiés et emballés dans toutes les autres situations.

Pour les couches d'entités, le paramètre Etendue est utilisé pour sélectionner les entités qui seront consolidées. Pour les couches raster, le paramètre Etendue est utilisé pour découper les jeux de données raster.

Les fichiers qui documentent les cartes et les données ou fournissent des informations supplémentaires peuvent être inclus dans le package. Des images, des PDF, des documents Word et des fichiers .zip peuvent être inclus dans le package en les référençant avec le paramètre Fichiers supplémentaires.

Avertir:

Les packages de projet (fichiers .ppkx) ne peuvent être créés et ouverts qu'avec ArcGIS Pro .


Questions fréquemment posées:

Oui! Nous sommes la même excellente entreprise qui propose une impression de billets d'événement de qualité supérieure et des prix bas avec le meilleur service client du moment ! Nous avons fait peau neuve afin de pouvoir offrir à nos clients encore plus de services, tels que nos plateformes de collecte de fonds et d'événements en ligne ainsi que des produits imprimés personnalisés !

Rapide comme l'éclair ! Si vous commandez des billets d'événement imprimés sur mesure avant 15 h. CST, ils seront expédiés de nos installations le jour ouvrable suivant, c'est un délai de 24 heures ! Passez votre commande le lundi avant 15h. CST, et il sera expédié mardi. N'oubliez pas que les week-ends ne comptent pas, donc si vous passez votre commande le samedi, elle sera traitée le lundi et expédiée le mardi. Pour les quantités supérieures à 5000 et les commandes de billets agrafés, le temps de traitement sera plus long. Cliquez ici pour plus de détails sur les délais de traitement rapide des billets.

Une fois que vos billets d'événement imprimés quittent nos installations, tout dépend d'UPS. Vous pouvez choisir l'option d'expédition qui correspond le mieux à votre emploi du temps et à votre budget. Vous trouverez une liste des méthodes d'expédition UPS sur notre page Délais de traitement rapide des billets. Vous pouvez également consulter la carte des délais d'expédition pour UPS Ground.

Oui! Votre satisfaction est notre priorité n°1, point final. Nous prenons grand soin de nous assurer de fournir des produits de la plus haute qualité à des prix abordables avec un délai d'exécution rapide. Si vous n'êtes pas entièrement satisfait de votre commande, veuillez contacter nos spécialistes du support client au 888.771.0809 ou à [email protected] Nous vous rembourserons intégralement le prix du produit moins les frais d'expédition ou refaire votre commande - à vous de choisir. En savoir plus sur notre garantie de satisfaction.

La conception réelle est gratuite, mais le prix exact de votre commande peut varier. Des éléments tels que l'encre couleur ou noire, le nombre de téléchargements d'images, votre choix d'agrafage, le type de papier que vous sélectionnez et, bien sûr, le nombre de billets ou d'autres produits que vous commandez affectent tous le prix.

Pour les billets les moins chers, choisissez un design noir et blanc sans images !

La plupart de nos billets d'événement sont équipés de talons. Si vous souhaitez une sélection de billets sans crampons, veuillez parcourir nos modèles de coupons et de tickets de boisson - ces modèles peuvent également servir de billets d'événement sans crampons. Certains clients d'Eventgroove ont même utilisé des invitations comme billets d'événement !

Oui! Commander des articles ensemble vous fera économiser sur les frais d'expédition mais retardera la livraison de vos billets car nos produits personnalisés ont un délai d'exécution plus long.

Étant donné que le processus de commande est différent pour les produits en ligne et personnalisés, veuillez ne pas terminer votre commande en ligne. Au lieu de cela, créez simplement un compte en ligne et ajoutez les billets à votre panier. Après avoir entré vos informations d'expédition et de facturation en ligne, veuillez appeler notre équipe de support client au 888.771.0809. Ils commenceront le processus de commande de produits personnalisés et finaliseront votre commande une fois toutes les informations nécessaires reçues.

C'est parce que l'épreuve ne reflète que l'impression, pas le fond ou la couleur du papier. Une fois imprimé, tout ce qui apparaît en blanc dans votre épreuve sera de la couleur du papier que vous avez sélectionné.

Vous pouvez! Nos preuves numériques offrent un bon fac-similé de votre billet physique. Cependant, si vous vous inquiétez de la qualité de nos modèles en ligne ou d'une image que vous avez téléchargée, vous pouvez appeler notre équipe de support client au 888.771.0809 et demander un échantillon physique. Nous mettrons votre commande en attente et vous enverrons un échantillon non perforé via UPS Next Day Air sans frais (gratuit !).

Étant donné que nous ne commençons jamais à imprimer tant qu'une épreuve n'est pas approuvée, veuillez garder à l'esprit que la demande d'une épreuve physique retardera votre commande. De plus, si vous appelez après qu'UPS a récupéré ses envois par avion le jour suivant pour la journée, nous ne pourrons pas expédier la feuille d'échantillons le même jour.

Une fois que vous avez reçu votre preuve physique, veuillez appeler le service client pour confirmer votre commande ou l'annuler sans frais. Si vous n'êtes pas satisfait de la preuve, nous vous rembourserons votre argent et vous pourrez apporter les modifications nécessaires à votre modèle en ligne avant de soumettre à nouveau la commande.

Nous espérons que vous le ferez ! Nous aimons partager. Si vous souhaitez vérifier la qualité de nos produits, nous sommes toujours heureux de vous envoyer un échantillon de colis sans frais. Vous pouvez demander plusieurs échantillons sur notre page d'échantillons gratuits.

Nous avons plusieurs stocks de papier de billets d'événement parmi lesquels choisir! Notre plus populaire est notre stock de couverture de 100 lb. Il est d'un blanc éclatant avec une finition non couchée ultra-lisse. Vous pouvez également choisir parmi un support de couverture 100 lb durable recyclé à 100 %, un support épais, un support de sécurité sensible à la chaleur 100 lb (11 pt), un support de sécurité UV épais de qualité souvenir enduit semi-brillant de 100 lb (11 pt). Les prix de nos stocks de cartes varient, alors lorsque vous examinez chaque type avant de passer à la caisse, gardez un œil sur le récapitulatif des prix sur la droite de votre écran !

Nous aimerions penser qu'ils sont tous les deux géniaux ! La finition lisse a un aspect mat tandis que la finition semi-brillante a plus de brillance, de sorte que les couleurs ont tendance à se démarquer davantage avec la finition semi-brillante. En dehors de cela, les deux papiers sont un stock de billets épais de qualité supérieure qui donne à vos billets un aspect professionnel et se sent bien en main. Ils ont à peu près le même poids qu'une carte de visite ou de voeux coûteuse.

Peu importe le design, le papier cartonné ou la taille qu'ils mesurent sur votre appareil ou votre écran d'ordinateur, vos billets imprimés mesurent 5,63 x 1,97 pouces. Ne vous souciez pas de vous souvenir des dimensions du billet : elles sont écrites dans la description du modèle de billet et sont affichées dans le récapitulatif de la commande avant de passer à la caisse !

Cela dépend du design que vous avez choisi! Chaque modèle de billet d'événement présente un motif et une mise en page uniques, ce qui rend le nombre de caractères par ligne différent pour chaque modèle. Pour voir si votre test correspond au modèle de billet d'événement que vous avez sélectionné, entrez simplement toutes vos informations dans le modèle de billet, puis cliquez sur « Afficher la preuve » au bas de la page. Si votre texte ne tient pas, les lignes avec trop de caractères apparaîtront en rouge dans votre épreuve. À partir de là, vous pouvez apporter des modifications pour vous assurer que votre texte correspond aux paramètres du modèle de billet d'événement. Gardez à l'esprit que les lettres majuscules ont besoin de plus d'espace que les lettres minuscules, et les dispositions verticales permettent généralement moins de texte que les dispositions horizontales.

Oui! Beaucoup de nos modèles de billets ont un espace pour télécharger votre propre image. Pour les trouver, tapez "image" dans notre champ de recherche, et notre vaste sélection de modèles de billets d'événement avec des spots de téléchargement d'images apparaîtra. N'oubliez pas que la conception de nos modèles de billets d'événement ne peut pas être modifiée - vous ne pouvez ajouter que du texte ou des images dans les champs disponibles.

Vous ne trouvez pas tout à fait le modèle de billet d'événement qui vous convient ? Nous pouvons créer un design personnalisé! Envoyez-nous simplement un e-mail à [email protected] avec les détails et nous vous fournirons un devis rapide.

Oui! Laissez simplement toutes les lignes vides dans le modèle en ligne, et cet espace restera vide sur votre produit d'impression fini. Cependant, comme nos modèles sont standardisés et que le processus est automatisé, il n'y a aucun moyen d'ajouter une ligne de texte ou de repositionner le texte sans payer pour une commande de billet personnalisé. Visitez notre page de demande de commande personnalisée pour plus d'informations.

Rien! Si vous choisissez de ne pas télécharger d'image, l'arrière-plan du modèle en ligne apparaîtra à l'endroit où vous verrez l'espace réservé à l'image.


Pourquoi mener une enquête sur les préoccupations?

La réalisation d'un sondage sur les préoccupations éclairera vos efforts pour vous assurer que les préoccupations urgentes des gens sont prises en compte. Raisons supplémentaires pour envisager de mener une enquête sur les préoccupations :

  • Il implique les membres de la communauté dans le processus de prise de décision dès le début, ce qui augmente leur probabilité de s'impliquer activement et de rester impliqués. Aider les membres de la communauté à commencer à réfléchir aux problèmes de santé et de développement communautaire les motive à s'impliquer. Ce sont leurs problèmes !
  • Il demande aux membres de la communauté de définir ce qu'ils considèrent comme le plus important. C'est le genre d'informations que vous n'obtiendrez pas de professionnels extérieurs.
  • Il peut s'agir d'un moyen fiable, systématique et facile à utiliser pour puiser dans l'information.
  • Il aide les membres de la coalition et les citoyens à comprendre comment ils perçoivent leur communauté.
  • Il fournit une source utile d'information et d'orientation pour les initiatives, les bailleurs de fonds et les participants.
  • Cela empêche l'agenda de votre organisation de refléter uniquement les intérêts des fournisseurs de services. Il est important d'avoir le point de vue des personnes que votre groupe sert.
  • Il aide à établir l'ordre du jour du travail communautaire.
  • Il construit un consensus.

2 Présentation

SWIG est un outil de développement logiciel qui simplifie la tâche d'interfacer différents langages avec les programmes C et C++. En un mot, SWIG est un compilateur qui prend les déclarations C et crée les wrappers nécessaires pour accéder à ces déclarations à partir d'autres langages, notamment Perl, Python, Tcl, Ruby, Guile et Java. SWIG ne nécessite normalement aucune modification du code existant et peut souvent être utilisé pour créer une interface utilisable en quelques minutes seulement. Les applications possibles de SWIG comprennent :

  • Construire des interfaces interprétées vers des programmes C existants.
  • Prototypage rapide et développement d'applications.
  • Débogage interactif.
  • Réingénierie ou refactorisation de logiciels hérités en composants de langage de script.
  • Faire une interface utilisateur graphique (en utilisant Tk par exemple).
  • Test de bibliothèques et de programmes C (à l'aide de scripts).
  • Construire des modules C hautes performances pour les langages de script.
  • Rendre la programmation C plus agréable (ou tolérable selon votre point de vue).
  • Impressionner vos amis.
  • Obtention d'importantes sommes d'argent pour la recherche (bien que cela ne soit évidemment pas applicable à l'auteur).

SWIG a été conçu à l'origine pour permettre aux scientifiques et aux ingénieurs de créer très facilement des logiciels scientifiques extensibles sans avoir à obtenir un diplôme en génie logiciel. Pour cette raison, l'utilisation de SWIG a tendance à être quelque peu informelle et ad-hoc (par exemple, SWIG n'exige pas que les utilisateurs fournissent des spécifications d'interface formelles comme vous le trouverez dans un compilateur IDL dédié). Bien que ce style de développement ne soit pas approprié pour tous les projets, il est particulièrement bien adapté au développement de logiciels dans les petits, en particulier aux travaux de recherche et de développement que l'on trouve couramment dans les projets scientifiques et d'ingénierie.

2.2 Pourquoi utiliser SWIG ?

Comme indiqué dans la section précédente, l'objectif principal de SWIG est de simplifier la tâche d'intégration de C/C++ avec d'autres langages de programmation. Cependant, pourquoi quelqu'un voudrait-il faire cela? Pour répondre à cette question, il est utile de lister quelques points forts de la programmation C/C++ :

  • Excellent support pour l'écriture de bibliothèques de programmation.
  • Hautes performances (numérotation, traitement de données, graphiques, etc.).
  • Programmation et intégration de systèmes.
  • Large communauté d'utilisateurs et base de logiciels.

Ensuite, listons quelques problèmes avec la programmation C/C++

  • L'écriture d'une interface utilisateur est plutôt pénible (c'est-à-dire, envisagez de programmer avec MFC, X11, GTK ou un certain nombre d'autres bibliothèques).
  • Les tests prennent du temps (le cycle de compilation/débogage).
  • Pas facile à reconfigurer ou à personnaliser sans recompilation.
  • La modularisation peut être délicate.
  • Problèmes de sécurité (débordement de buffer par exemple).

Pour remédier à ces limitations, de nombreux programmeurs sont arrivés à la conclusion qu'il est beaucoup plus facile d'utiliser différents langages de programmation pour différentes tâches. Par exemple, écrire une interface utilisateur graphique peut être considérablement plus facile dans un langage de script comme Python ou Tcl (considérez les raisons pour lesquelles des millions de programmeurs ont utilisé des langages comme Visual Basic si vous avez besoin de plus de preuves). Un interpréteur interactif peut également servir d'outil de débogage et de test utile. D'autres langages comme Java pourraient grandement simplifier la tâche d'écriture de logiciels informatiques distribués. Le point clé est que les différents langages de programmation offrent des forces et des faiblesses différentes. De plus, il est extrêmement improbable qu'une programmation soit jamais parfaite. Par conséquent, en combinant les langues, vous pouvez utiliser les meilleures fonctionnalités de chaque langue et simplifier considérablement certains aspects du développement logiciel.

  • Une collection de fonctions et de variables qui font quelque chose d'utile.
  • UNE principale() programme qui démarre tout.
  • Une horrible collection de hacks qui forment une sorte d'interface utilisateur (mais que personne ne veut vraiment toucher).

Au lieu de suivre cette voie, l'incorporation de C/C++ dans un langage de niveau supérieur se traduit souvent par une conception plus modulaire, moins de code, une meilleure flexibilité et une productivité accrue du programmeur.

SWIG essaie de rendre le problème de l'intégration C/C++ aussi simple que possible. Cela vous permet de vous concentrer sur le programme C sous-jacent et d'utiliser l'interface de langage de haut niveau, mais pas la corvée fastidieuse et complexe de faire parler les deux langages. Dans le même temps, SWIG reconnaît que toutes les applications sont différentes. Par conséquent, il fournit une grande variété de fonctionnalités de personnalisation qui vous permettent de modifier presque tous les aspects des liaisons de langue. C'est la principale raison pour laquelle SWIG a un si grand manuel d'utilisation -).

2.3 Un exemple SWIG

La meilleure façon d'illustrer SWIG est d'utiliser un exemple simple. Considérez le code C suivant :

Supposons que vous vouliez accéder à ces fonctions et à la variable globale Ma_variable de Tcl. Vous commencez par créer un fichier d'interface SWIG comme indiqué ci-dessous (par convention, ces fichiers portent un suffixe .i) :

2.3.1 Fichier d'interface SWIG

Le fichier d'interface contient des prototypes de fonctions ANSI C et des déclarations de variables. Le %module La directive définit le nom du module qui sera créé par SWIG. Le Le bloc % fournit un emplacement pour insérer du code supplémentaire tel que des fichiers d'en-tête C ou des déclarations C supplémentaires.

2.3.2 La commande swig

SWIG est invoqué à l'aide de la lampée commander. Nous pouvons l'utiliser pour construire un module Tcl (sous Linux) comme suit :

Le lampée commande a produit un nouveau fichier appelé exemple_enveloppe.c qui doit être compilé avec le exemple.c fichier. La plupart des systèmes d'exploitation et des langages de script prennent désormais en charge le chargement dynamique des modules. Dans notre exemple, notre module Tcl a été compilé dans une bibliothèque partagée qui peut être chargée dans Tcl. Une fois chargé, Tcl peut désormais accéder aux fonctions et variables déclarées dans l'interface SWIG. Un coup d'oeil au fichier exemple_enveloppe.c révèle un horrible gâchis. Cependant, vous n'avez presque jamais besoin de vous en soucier.

2.3.3 Construire un module Perl5

Maintenant, transformons ces fonctions en un module Perl5. Sans apporter de modifications, tapez ce qui suit (indiqué pour Solaris) :

2.3.4 Construire un module Python

Enfin, construisons un module pour Python (illustré pour Irix).

2.3.5 Raccourcis

Pour le programmeur vraiment paresseux, on peut se demander pourquoi nous avions besoin du fichier d'interface supplémentaire. Il s'avère que vous pouvez souvent vous en passer. Par exemple, vous pouvez également créer un module Perl5 en exécutant simplement SWIG sur le fichier d'en-tête C et en spécifiant un nom de module comme suit

2.4 Fonctionnalités du langage C/C++ prises en charge

L'un des principaux objectifs du projet SWIG est de rendre le processus de liaison linguistique extrêmement simple. Bien que quelques exemples simples aient été montrés, SWIG est tout à fait capable de supporter la plupart du C++. Certaines des principales caractéristiques comprennent :

  • Prétraitement complet du C99.
  • Tous les types de données ANSI C et C++.
  • Fonctions, variables et constantes.
  • Des classes.
  • Héritage simple et multiple.
  • Fonctions et méthodes surchargées.
  • Opérateurs surchargés.
  • Modèles C++ (y compris les modèles de membres, la spécialisation et la spécialisation partielle).
  • Espaces de noms.
  • Arguments de longueur variable.
  • Pointeurs intelligents C++.

Actuellement, la seule fonctionnalité majeure de C++ non prise en charge est les classes imbriquées - une limitation qui sera supprimée dans une future version.

Il est important de souligner que SWIG n'est pas un outil de lexage C++ simpliste comme plusieurs outils de génération de wrappers apparemment similaires. SWIG n'analyse pas seulement le C++, il implémente le système de types C++ complet et il est capable de comprendre la sémantique C++. SWIG génère ses wrappers en toute connaissance de cause. En conséquence, vous constaterez que SWIG est tout aussi capable de gérer les cas difficiles qu'il ne l'est pour encapsuler du code C++ simple. En fait, SWIG est capable de gérer le code C++ qui met l'accent sur les limites mêmes de nombreux compilateurs C++.

2.5 Construction d'interface non intrusive

Lorsqu'il est utilisé comme prévu, SWIG nécessite une modification minimale (le cas échéant) du code C ou C++ existant. Cela rend SWIG extrêmement facile à utiliser avec les packages existants et favorise la réutilisation et la modularité des logiciels. En rendant le code C/C++ indépendant de l'interface de haut niveau, vous pouvez modifier l'interface et réutiliser le code dans d'autres applications. Il est également possible de prendre en charge différents types d'interfaces selon l'application.

2.6 Intégrer SWIG dans un système de build

SWIG est un outil en ligne de commande et, en tant que tel, peut être intégré à tout système de construction prenant en charge l'appel d'outils/compilateurs externes. SWIG est le plus souvent invoqué à partir d'un Makefile, mais est également connu pour être invoqué à partir d'IDE populaires tels que Microsoft Visual Studio.

Si vous utilisez GNU Autotools (Autoconf/ Automake/ Libtool) pour configurer l'utilisation de SWIG dans votre projet, les macros SWIG Autoconf peuvent être utilisées. La macro principale est ac_pkg_swig, voir http://www.gnu.org/software/ac-archive/htmldoc/ac_pkg_swig.html. Le ac_python_devel La macro est également utile pour générer des extensions Python. Consultez l'archive de macros Autoconf pour plus d'informations sur cette macro et d'autres macros Autoconf.

Il existe une prise en charge croissante de SWIG dans certains outils de construction, par exemple CMake est un gestionnaire de construction multiplateforme et open source avec une prise en charge intégrée de SWIG. CMake peut détecter l'exécutable SWIG et de nombreuses bibliothèques de langage cible pour la liaison. CMake sait comment créer des bibliothèques partagées et des modules chargeables sur de nombreux systèmes d'exploitation différents. Cela permet un développement SWIG multiplateforme facile. Il peut également générer les commandes personnalisées nécessaires pour piloter SWIG à partir des IDE et des makefiles. Tout cela peut être fait à partir d'un seul fichier d'entrée multiplateforme. L'exemple suivant est un fichier d'entrée CMake permettant de créer un wrapper python pour le fichier d'interface SWIG, example.i :

L'exemple ci-dessus générera des fichiers de construction natifs tels que des makefiles, des fichiers nmake et des projets Visual Studio qui invoqueront SWIG et compileront les fichiers C++ générés dans _example.so (UNIX) ou _example.pyd (Windows). Pour les autres langues cibles sous Windows, une dll, au lieu d'un fichier .pyd, est généralement générée.

2.7 Génération de code sans intervention

SWIG est conçu pour produire un code fonctionnel qui ne nécessite aucune modification manuelle (en fait, si vous regardez le résultat, vous ne voudrez probablement pas le modifier). Vous devez penser que votre interface en langue cible est entièrement définie par l'entrée de SWIG, et non par le fichier de sortie résultant. Bien que cette approche puisse limiter la flexibilité pour les hackers invétérés, elle permet à d'autres d'oublier les détails d'implémentation de bas niveau.

2.8 SWIG et liberté

Non, ce n'est pas une section spéciale sur le triste état de la politique mondiale. Cependant, il peut être utile de savoir que SWIG a été écrit avec une certaine "philosophie" sur la programmation --- à savoir que les programmeurs sont intelligents et que les outils doivent rester à l'écart. Pour cette raison, vous constaterez que SWIG est extrêmement permissif dans ce qu'il vous permet de faire. En fait, vous pouvez utiliser SWIG pour aller bien au-delà de "vous tirer une balle dans le pied" si une programmation dangereuse est votre objectif. D'un autre côté, ce genre de liberté peut être exactement ce qui est nécessaire pour travailler avec des applications C/C++ compliquées et inhabituelles.

Ironiquement, la liberté offerte par SWIG est contrée par une approche extrêmement conservatrice de la génération de code. À la base, SWIG essaie de distiller même le code C++ le plus avancé en un petit ensemble bien défini de techniques de construction d'interfaces basées sur la programmation C ANSI. Pour cette raison, vous constaterez que les interfaces SWIG peuvent être facilement compilées par pratiquement tous les compilateurs C/C++ et qu'elles peuvent être utilisées sur n'importe quelle plate-forme. Encore une fois, c'est une partie importante pour rester à l'écart du programmeur ---- la dernière chose qu'un développeur veut faire est de passer son temps à déboguer la sortie d'un outil qui repose sur des fonctionnalités de programmation non portables ou peu fiables.


2.6 Configuration des numéros suivants pour les documents juridiques

Cette section donne un aperçu des numéros suivants pour les documents juridiques et explique comment configurer les numéros suivants.

2.6.1 Comprendre les numéros suivants pour les documents juridiques

La numérotation de chaque type de document juridique doit être consécutive. Étant donné que vous pouvez imprimer certains documents juridiques à partir de plusieurs programmes JD Edwards EnterpriseOne, vous configurez les numéros suivants pour les documents juridiques afin que le système attribue un numéro suivant valide quel que soit le programme que vous utilisez pour imprimer un document.

Vous utilisez le programme Numéro suivant du document juridique (P740001) pour configurer différents schémas de numérotation suivants pour chaque type de document juridique. Par exemple, vous pouvez configurer un schéma de numérotation suivant pour les factures standard et un autre schéma de numérotation suivant pour les factures avec TVA.

Le système stocke les schémas de numérotation suivants dans la table Numéros suivants des documents juridiques (F7400001).

2.6.2 Formulaires utilisés pour configurer les numéros suivants pour les documents juridiques

Nom de forme ID de formulaire La navigation Usage
Travailler avec les prochains numéros de document juridique W740001A Configuration du document juridique (G74LDOC), numéro suivant du document juridique Passez en revue ou sélectionnez un schéma de numérotation existant.
Prochaine révision des numéros de documents juridiques W740001B Dans l'écran Travailler avec les prochains numéros de document juridique, cliquez sur Ajouter. Configurez les numéros suivants pour les documents juridiques.

2.6.3 Configuration des numéros suivants pour les documents juridiques

Accédez au formulaire Prochaine révision des numéros de document juridique.

Figure 2-4 Formulaire de révision des numéros de document juridique suivant

Saisissez l'entreprise pour laquelle vous configurez les numéros suivants.

Saisissez le type de document juridique pour lequel vous configurez les numéros suivants. La valeur que vous saisissez doit exister dans la table F7400002.

Saisissez le code qui représente le lieu d'émission du document juridique. La valeur que vous saisissez doit exister dans la table F7400004.

Type de document juridique Identique à

Saisissez le type de document juridique qui partage le même schéma de numérotation suivant. La valeur que vous saisissez doit exister dans la table F7400002.

Entrez le numéro qui précède le numéro que le système utilise comme premier numéro dans le schéma de numérotation suivant. Par exemple, si vous saisissez 99, le système utilise 100 comme premier numéro dans le schéma de numéros suivant pour le type de document juridique que vous spécifiez.


2.5 Modèles

Un thème Hugo se compose de deux composants principaux : des modèles et des ressources Web. Le premier est essentiel et indique à Hugo comment rendre une page. 22 Cette dernière est facultative mais également importante. Il se compose généralement de fichiers CSS et JavaScript, ainsi que d'autres actifs tels que des images et des vidéos. Ces actifs déterminent l'apparence et les fonctionnalités de votre site Web, et certains peuvent être intégrés au contenu de vos pages Web.

Vous pouvez en savoir plus sur les modèles Hugo dans la documentation officielle (https://gohugo.io/templates/overview/). Il existe de nombreux types de modèles différents. Pour vous permettre de maîtriser plus facilement les idées clés, j'ai créé un thème Hugo très minimal, qui couvre la plupart des fonctionnalités dont un utilisateur moyen peut avoir besoin, mais le nombre total de lignes n'est que d'environ 150, nous pouvons donc parler de toute la source code de ce thème dans la sous-section suivante.

2.5.1 Un exemple minimal

XMin est un thème Hugo que j'ai écrit à partir de zéro en 12 heures environ. Environ une demi-heure a été consacrée aux modèles, 3,5 heures à peaufiner les styles CSS et 8 heures à la documentation (https://xmin.yihui.org). Je pense que cela peut être un cas représentatif du temps que vous consacreriez à chaque partie lors de la conception d'un thème. C'est peut-être dans notre nature de passer beaucoup plus de temps sur des trucs cosmétiques comme CSS que sur des trucs essentiels comme les modèles. Pendant ce temps, le codage est souvent plus facile que la documentation.

Nous allons montrer le code source du thème XMin. Le thème pouvant être mis à jour occasionnellement dans le futur, vous pouvez suivre ce lien pour obtenir une version corrigée dont nous parlerons dans cette section : https://github.com/yihui/hugo-xmin/tree/4bb305. Vous trouverez ci-dessous une arborescence de tous les fichiers et répertoires du thème :

LICENSE.md et README.md ne sont pas des composants obligatoires d'un thème, mais vous devez absolument choisir une licence pour votre code source afin que d'autres personnes puissent utiliser correctement votre code, et un README peut être la brève documentation de votre logiciel.

Le fichier archétypes/default.md définit le modèle par défaut sur la base duquel les utilisateurs peuvent créer de nouveaux articles. Dans ce thème, default.md n'a fourni que des métadonnées YAML vides :

Les répertoires les plus importants d'un thème sont layouts/ et static/ . Les modèles HTML sont stockés sous layouts/ , et les actifs sont stockés sous static/ .

Pour comprendre layouts/ , vous devez connaître quelques notions de base sur HTML (voir Section B.1) car les modèles sous ce répertoire sont pour la plupart des documents ou fragments HTML. Il existe de nombreux types de sous-répertoires possibles sous layouts/ , mais nous n'en présenterons que deux ici : _default/ et partials/ .

Le répertoire _default/ est l'endroit où vous placez les modèles par défaut pour vos pages Web. Dans le thème XMin, nous avons trois modèles : single.html , list.html et terms.html .

single.html est un modèle pour le rendu de pages individuelles. Une seule page correspond essentiellement à un document Markdown sous content/ , et elle contient à la fois les métadonnées (YAML) et le contenu. En règle générale, nous souhaitons afficher le titre de la page, l'auteur, la date et le contenu. Ci-dessous se trouve le code source du single.html de XMin :

Vous voyez beaucoup de paires d'accolades doubles <<>> , et c'est ainsi que vous programmez les modèles en utilisant les variables et les fonctions de Hugo.

Le modèle commence par un modèle partiel header.html , pour lequel vous verrez bientôt le code source. Pour l'instant, vous pouvez l'imaginer comme toutes les balises HTML avant le corps de votre page (par exemple, <html><head> ). Les modèles partiels sont principalement destinés à la réutilisation du code HTML. Par exemple, toutes les pages HTML peuvent partager des balises <head></head> très similaires, et vous pouvez factoriser les parties communes dans des modèles partiels.

Les métadonnées d'une page sont incluses dans un élément <div> avec la classe article-meta . Nous vous recommandons d'affecter des classes aux éléments HTML lors de la conception de modèles, afin qu'il soit plus facile d'appliquer des styles CSS à ces éléments en utilisant des noms de classe. Dans un modèle, vous avez accès à de nombreuses variables fournies par Hugo, par exemple, la variable .Title stocke la valeur du titre de la page, et nous écrivons le titre dans un <span> dans un en-tête de premier niveau <h1> . De même, l'auteur et la date sont écrits en <h2> , mais uniquement s'ils sont fournis dans les métadonnées YAML. La syntaxe << avec FOO >><< . >>> fin >> est un raccourci de <><< FOO >><< end >> , c'est-à-dire que cela vous évite de saisir deux fois l'expression FOO en utilisant << . >> . La méthode .Format peut être appliquée à un objet date, et dans ce thème, nous formatons les dates sous la forme AAAA/mm/jj (le 02/01/2006 est le moyen de spécifier le format dans Go).

Ensuite, nous montrons le contenu d'une page, qui est stocké dans la variable .Content . Le contenu est enveloppé dans une balise HTML sémantique <main> .

Le modèle est terminé après avoir inclus un autre modèle partiel footer.html (le code source sera affiché sous peu).

Pour faciliter la compréhension du fonctionnement d'un modèle, nous montrons un exemple de publication minimal ci-dessous :

En utilisant le modèle single.html , il sera converti en une page HTML avec un code source qui ressemble plus ou moins à ceci (avec l'en-tête et le pied de page omis) :

Pour un exemple complet d'une seule page, vous pouvez voir https://xmin.yihui.org/about/.

list.html is the template for rendering lists of pages, such as a list of blog posts, or a list of pages within a category or tag. Here is its source code:

Again, it uses two partial templates header.html and footer.html . The expression <> means, if this list is not the home page, show the page title. This is because I do not want to display the title on the homepage. It is just my personal preference. You can certainly display the title in <h1> on the home page if you want.

The << .Content >> shows the content of the list. Please note that typically .Content is empty, which may be surprising. This is because a list page is not generated from a source Markdown file by default. Cependant, il existe une exception. When you write a special Markdown file _index.md under a directory corresponding to the list name, the .Content of the list will be the content of this Markdown file. For example, you can define the content of your homepage in content/_index.md , and the content of the post list page under content/post/_index.md .

Next we generate the list using a loop ( range ) through all pages filtered by the condition that the section of a page should not be empty. “Section” in Hugo means the first-level subdirectory name under content/ . For example, the section of content/post/foo.md is post . Therefore the filter means that we will list all pages under subdirectories of content/ . This will exclude pages under the root content/ directory, such as content/about.md .

Please note that the variable .Data is dynamic, and its value changes according to the specific list you want to generate. For example, the list page https://xmin.yihui.org/post/ only contains pages under content/post/ , and https://xmin.yihui.org/note/ only contains pages under content/note/ . These list pages are automatically generated by Hugo, and you do not need to explicitly loop through the sections post and note . That is, a single template list.html will generate multiple lists of pages according to the sections and taxonomy terms (e.g., categories and tags) you have on your website.

The list items are represented by the HTML tags <li> in <ul> . Each item consists of the date, link, and title of a page. You may see https://xmin.yihui.org/post/ for a full example of a list page.

terms.html is the template for the home page of taxonomy terms. For example, you can use it to generate the full list of categories or tags. The source code is below:

Similar to list.html , it also uses a loop. The variable .Data.Terms stores all terms under a taxonomy, e.g., all category names. You can think of it as a named list in R (called a map in Go), with the names being the terms and the values being lists of pages. The variable $key denotes the term and $value denotes the list of pages associated with this term. What we render in each <li> is a link to the term page as well as the count of posts that used this term ( len is a Go function that returns the length of an object).

Hugo automatically renders all taxonomy pages, and the path names are the plural forms of the taxonomies, e.g., https://xmin.yihui.org/categories/ and https://xmin.yihui.org/tags/. That is the meaning of .Data.Plural . The leading $ is required because we are inside a loop, and need to access variables from the outside scope. The link of the term is passed to the Hugo function relURL via a pipe | to make it relative, which is good practice because relative links are more portable (independent of the domain name).

The partials/ directory is the place to put the HTML fragments to be reused by other templates via the partial function. We have four partial templates under this directory:

header.html main defines the <head> tag and the navigation menu in the <nav> tag.

The <head> area should be easy to understand if you are familiar with HTML. Note that we also included a partial template head_custom.html , which is empty in this theme, but it will make it much easier for users to add customized code to <head> without rewriting the whole template. See Section 2.6 for more details.

The navigation menu is essentially a list, and each item of the list is read from the variable .Site.Menus.main . This means users can define the menu in config.toml , e.g.,

It will generate a menu like this:

Hugo has a powerful menu system, and we only used the simplest type of menu in this theme. If you are interested in more features like nested menus, please see the full documentation at http://gohugo.io/extras/menus/.

footer.html defines the footer area of a page and closes the HTML document:

The purpose of the partial template foot_custom.html is the same as head_custom.html that is, to allow the user to add customized code to the <footer> without rewriting the whole template.

Lastly, we use the variable .Site.Params.footer to generate a page footer. Note we used the with function again. Recall that the syntax << with .Site.Params.footer >><< . >><< end >> is a shorthand for <><< .Site.Params.footer >><< end >> . This syntax saves you from typing the expression .Site.Params.footer twice by using << . >> as a placeholder for the variable footer , which is defined as a site parameter in our config.toml file. The additional function markdownify can convert Markdown to HTML (i.e., << . | markdownify >> . Altogether, this sequence means we can define a footer option using Markdown under params in config.toml , e.g.,

There is a special template 404.html , which Hugo uses to create the 404 page (when a page is not found, this page is displayed):

With all templates above, we will be able to generate a website from Markdown source files. You are unlikely to be satisfied with the website, however, because the HTML elements are not styled at all, and the default appearance may not look appealing to most people. You may have noticed that in header.html , we have included two CSS files, /css/style.css and /css/fonts.css .

You can find many existing open-source CSS frameworks online that may be applied to a Hugo theme. For example, the most popular CSS framework may be Bootstrap: http://getbootstrap.com. When I was designing XMin, I wondered how far I could go without using any of these existing frameworks, because they are usually very big. For example, bootstrap.css has nearly 10000 lines of code when not minimized. It turned out that I was able to get a satisfactory appearance with about 50 lines of CSS, which I will explain in detail below:

style.css defines all styles except the typefaces:

The maximum width of the page body is set to 800 pixels because an excessively wide page is difficult to read ( 800 is an arbitrary threshold that I picked). The body is centered using the CSS trick margin: auto , which means the top, right, bottom, and left margins are automatic. When a block element’s left and right margins are auto , it will be centered.

Remember that our menu element is a list <ul > defined in header.html . I changed the default display style of <li> within the menu to inline-block , so that they will be laid out from left to right as inline elements, instead of being stacked vertically as a bullet list (the default behavior).

For links ( <a> ) in the menu and the metadata area of an article, the default text decoration (underlines) is removed, and a light background color is applied. The border radius is set to 5 pixels so that you can see a subtle round-corner rectangle behind each link.

The horizontal rule ( <hr> ) is set to a dashed light-gray line to make it less prominent on a page. These rules are used to separate the article body from the header and footer areas.

For code blocks ( <pre> ), I apply light gray borders with drop-shadow effects. Every inline code element has a very light gray background. These decorations are merely out of my own peculiar interest and emphasis in code.

Embedded elements like images and videos that exceed the page margin are often ugly, so I restrict their maximum width to 100%. Hyphenation is turned on for words in <main> . Blockquotes have a gray left sidebar and a light gray background. Tables are centered by default, with only three horizontal rules: the top and bottom borders of the table, and the bottom border of the table head. Table rows are striped to make it easier to read the table especially when the table is wide.

fonts.css is a separate style sheet because it plays a critical role in the appearance of a website, and it is very likely that you will want to customize this file. In most cases, your readers will spend the most time on reading the text on your pages, so it is important to make the text comfortable to read. I’m not an expert in web design, and I just picked Palatino for the body and Lucida Console or Monaco (whichever is available in your system) for the code. It is common to use Google web fonts nowadays. You may try some web fonts and see if you like any of them.

The two CSS files are placed under the static/css/ directory of the theme. In the HTML template header.html , the path /css/style.css refers to the file static/css/style.css .

Lastly, this theme provided an example site under exampleSite/ . The directory structure may be a little confusing because this is a theme instead of a website. In practice, everything under exampleSite/ should be under the root directory of a website, and the top-level hugo-xmin/ directory should be under the themes/ directory of this website, i.e.,

The example site provides a sample config.toml , a home page _index.md , an about page about.md , two posts under note/ and two under post/ . It also overrides the foot_custom.html in the theme.

2.5.2 Implementing more features

The XMin is actually a highly functional theme, but we understand that it may be too minimal for you. There are a few commonly used features (intentionally) missing in this theme, and we will teach you how to add them by yourself if desired. All these features and the source code can be applied to other themes, too.

Enable Google Analytics. Hugo has provided a built-in partial template. For XMin, you can add

to layouts/partials/foot_custom.html under the root directory of your website (instead of themes/hugo-xmin/ ), and configure googleAnalytics in the config.toml . See https://github.com/yihui/hugo-xmin/pull/3 for details, and the HTML source of this page for the JavaScript rendered from the template: https://deploy-preview-3--hugo-xmin.netlify.com.

Enable Disqus comments. Similar to Google Analytics, you can add the built-in template

to foot_custom.html , and configure the Disqus shortname in config.toml . See https://github.com/yihui/hugo-xmin/pull/4 for details, and a preview at https://deploy-preview-4--hugo-xmin.netlify.com.

Enable syntax highlighting via highlight.js. Add this to head_custom.html

and this to foot_custom.html :

Remember to replace YOUR-CDN-LINK with the link to your preferred CDN host of highlight.js, e.g., cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0 . For more information about highlight.js, please see its homepage: https://highlightjs.org. If you need to use other CDN hosts, cdnjs.com is a good choice: https://cdnjs.com/libraries/highlight.js You can also see which languages and CSS themes are supported there.

Support math expressions through MathJax. Add the code below to foot_custom.html .

This requires substantial knowledge of JavaScript and familiarity with MathJax to fully understand the code above, and we will leave the explanation of the code to Section B.3.

Remember to replace YOUR-CDN-LINK with the link to your preferred CDN host of MathJax, e.g., cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5 .

Show the table of contents (TOC). To show a TOC for R Markdown posts, you only need to add the output format blogdown::html_page with the option toc: true to YAML:

For plain Markdown posts, you have to modify the template single.html . The TOC of a post is stored in the Hugo template variable .TableOfContents . You may want an option to control whether to show the TOC, e.g., you may add an option toc: true to the YAML metadata of a Markdown post to show the TOC. The code below can be added before the content of a post in single.html :

Display categories and tags in a post if provided in its YAML. Add the code below where you want to place the categories and tags in single.html , e.g., in <div ></div> .

Basically the code loops through the YAML metadata fields categories and tags , and for each field, its value is obtained from .Param , then we use an inside loop to write out the terms with links of the form <a href="/tags/foo/">foo</a> .

Add pagination. When you have a large number of posts on a website, you may not want to display the full list on a single page, but show N posts (e.g., N = 10) per page. It is easy to add pagination to a website using Hugo’s built-in functions and templates. Instead of looping through all posts in a list template (e.g., range .Data.Pages ), you paginate the full list of posts using the function .Paginate (e.g., range (.Paginate .Data.Pages) ). Below is a template fragment that you may insert to your template file list.html :

Add a GitHub Edit button or link to a page. If none of the above features look exciting to you (which would not surprise me), this little feature is really a great example of showing you the power of plain-text files and static websites, when combined with GitHub (or other services that support the online editing of plain-text files). I believe it would be difficult, if not impossible, to implement this feature in dynamic website frameworks like WordPress.

Basically, when you browse any text files in a repository on GitHub, you can edit them right on the page by hitting the Edit button (see Figure 2.3 for an example) if you have a GitHub account. If you have write access to the repository, you can commit the changes directly online, otherwise GitHub will fork the repository for you automatically, so that you can edit the file in your own repository, and GitHub will guide you to create a pull request to the original repository. When the original owner sees the pull request, he/she can see the changes you made and decide whether to accept them or not or ask you to make further changes. Although the terminology “pull request” is highly confusing to beginners, 23 it is probably the single greatest feature invented by GitHub, because it makes it so much easier for people to make contributions.

What is really handy is that all you need is a URL of a fixed form to edit a file on GitHub: https://github.com/USER/REPO/edit/BRANCH/PATH/TO/FILE . For example, https://github.com/rbind/yihui/edit/master/content/knitr/faq.md, where USER is rbind , REPO is yihui , BRANCH is master , and the file path is content/knitr/faq.md .

The key to implementing this feature is the variable .File.Path , which gives us the source file path of a page under content/ , e.g., post/foo.md . If your website only uses plain Markdown files, the implementation will be very simple. I omitted the full GitHub URL in . below, of which an example could be https://github.com/rbind/yihui/edit/master/content/ .

However, the case is a little more complicated for blogdown users, when R Markdown posts are involved. You cannot just use .File.Path because it actually points to the .html output file from an .Rmd file, whereas the .Rmd file is the actual source file. The Edit button or link should not point to the .html file. Below is the complete implementation that you may add to a template file depending on where you want to show the Edit link (e.g., footer.html ):

The basic logic is that for a file, if the same filename with the extension .Rmd exists, we will point the Edit link to the Rmd file. First, we define a variable $Rmd to be the filename with the .Rmd extension. Then we check if it exists. Unfortunately, there is no function in Hugo like file.exists() in R, so we have to use a hack: list all files under the directory and see if the Rmd file is in the list. $.Scratch is the way to dynamically store and obtain variables in Hugo templates. Most variables in Hugo are read-only, and you have to use $.Scratch when you want to modify a variable. We set a variable FilePath in $.Scratch , whose value is the full path to the Rmd file when the Rmd file exists, and the path to the Markdown source file otherwise. Finally, we concatenate a custom option GithubEdit in config.toml with the file path to complete the Edit link <a> . Here is an example of the option in config.toml :

Please note that if you use Hugo on Windows to build and deploy your site, you may have to change the file path separators from backslashes to forward slashes, e.g., you may need << $.Scratch.Set "FilePath" (replace ($.Scratch.Get "FilePath") "" "/") >> in the template. To avoid this complication, we do not recommend that you deploy your site through Windows (see Chapter 3 for deployment methods).

You may see https://github.com/yihui/hugo-xmin/pull/6 for an actual implementation with R Markdown examples, and see the footer of this page for the Edit link: https://deploy-preview-6--hugo-xmin.netlify.com. You can actually see a link in the footer of every page, except the lists of pages (because they do not have source files).

FIGURE 2.3: Edit a text file online on GitHub.

After you digest the XMin theme and the implementations of additional features, it should be much easier to understand other people’s templates. There are a large number of Hugo themes but the primary differences among them are often in styles. The basic components of templates are often similar.

The most common functionality of templates is to render HTML pages, but there can also be special templates, for example, for RSS feeds and sitemaps, which are XML files.↩︎


The Context¶

The template context holds the variables of a template. It stores the values passed to the template and also the names the template exports. Creating instances is neither supported nor useful as it’s created automatically at various stages of the template evaluation and should not be created by hand.

The context is immutable. Modifications on parent ne doit pas happen and modifications on vars are allowed from generated template code only. Template filters and global functions marked as contextfunction() s get the active context passed as first argument and are allowed to access the context read-only.

The template context supports read only dict operations ( get , keys , values , items , iterkeys , itervalues , iteritems , __getitem__ , __contains__ ). Additionally there is a resolve() method that doesn’t fail with a KeyError but returns an Undefined object for missing variables.

A dict of read only, global variables the template looks up. These can either come from another Context , from the Environment.globals or Template.globals or points to a dict created by combining the globals with the variables passed to the render function. It must not be altered.

The template local variables. This list contains environment and context functions from the parent scope as well as local modifications and exported variables from the template. The template will modify this dict during template evaluation but filters and context functions are not allowed to modify it.

The environment that loaded the template.

This set contains all the names the template exports. The values for the names are in the vars dict. In order to get a copy of the exported variables as dict, get_exported() can be used.

The load name of the template owning this context.

A dict with the current mapping of blocks in the template. The keys in this dict are the names of the blocks, and the values a list of blocks registered. The last item in each list is the current active block (latest in the inheritance chain).

Call the callable with the arguments and keyword arguments provided but inject the active context or environment as first argument if the callable is a contextfunction() or environmentfunction() .

Return the complete context as dict including the exported variables. For optimizations reasons this might not return an actual copy so be careful with using it.

Get a new dict with the exported variables.

Looks up a variable like __getitem__ or get but returns an Undefined object with the name of the name looked up.

Context is immutable for the same reason Python’s frame locals are immutable inside functions. Both Jinja2 and Python are not using the context / frame locals as data storage for variables but only as primary data source.

When a template accesses a variable the template does not define, Jinja2 looks up the variable in the context, after that the variable is treated as if it was defined in the template.


2.6 Git Basics - Tagging

Like most VCSs, Git has the ability to tag specific points in a repository’s history as being important. Typically, people use this functionality to mark release points ( v1.0 , v2.0 and so on). In this section, you’ll learn how to list existing tags, how to create and delete tags, and what the different types of tags are.

Listing Your Tags

Listing the existing tags in Git is straightforward. Just type git tag (with optional -l or --list ):

This command lists the tags in alphabetical order the order in which they are displayed has no real importance.

You can also search for tags that match a particular pattern. The Git source repo, for instance, contains more than 500 tags. If you’re interested only in looking at the 1.8.5 series, you can run this:

If you want just the entire list of tags, running the command git tag implicitly assumes you want a listing and provides one the use of -l or --list in this case is optional.

If, however, you’re supplying a wildcard pattern to match tag names, the use of -l or --list is mandatory.

Creating Tags

Git supports two types of tags: lightweight et annotated.

A lightweight tag is very much like a branch that doesn’t change — it’s just a pointer to a specific commit.

Annotated tags, however, are stored as full objects in the Git database. They’re checksummed contain the tagger name, email, and date have a tagging message and can be signed and verified with GNU Privacy Guard (GPG). It’s generally recommended that you create annotated tags so you can have all this information but if you want a temporary tag or for some reason don’t want to keep the other information, lightweight tags are available too.

Annotated Tags

Creating an annotated tag in Git is simple. The easiest way is to specify -a when you run the tag command:

The -m specifies a tagging message, which is stored with the tag. If you don’t specify a message for an annotated tag, Git launches your editor so you can type it in.

You can see the tag data along with the commit that was tagged by using the git show command:

That shows the tagger information, the date the commit was tagged, and the annotation message before showing the commit information.

Lightweight Tags

Another way to tag commits is with a lightweight tag. This is basically the commit checksum stored in a file — no other information is kept. To create a lightweight tag, don’t supply any of the -a , -s , or -m options, just provide a tag name:

This time, if you run git show on the tag, you don’t see the extra tag information. The command just shows the commit:

Tagging Later

You can also tag commits after you’ve moved past them. Suppose your commit history looks like this:

Now, suppose you forgot to tag the project at v1.2, which was at the “Update rakefile” commit. You can add it after the fact. To tag that commit, you specify the commit checksum (or part of it) at the end of the command:

You can see that you’ve tagged the commit:

Sharing Tags

By default, the git push command doesn’t transfer tags to remote servers. You will have to explicitly push tags to a shared server after you have created them. This process is just like sharing remote branches — you can run git push origin <tagname> .

If you have a lot of tags that you want to push up at once, you can also use the --tags option to the git push command. This will transfer all of your tags to the remote server that are not already there.

Now, when someone else clones or pulls from your repository, they will get all your tags as well.

git push <remote> --tags will push both lightweight and annotated tags. There is currently no option to push only lightweight tags, but if you use git push <remote> --follow-tags only annotated tags will be pushed to the remote.

Deleting Tags

To delete a tag on your local repository, you can use git tag -d <tagname> . For example, we could remove our lightweight tag above as follows:

Note that this does not remove the tag from any remote servers. There are two common variations for deleting a tag from a remote server.

The first variation is git push <remote> :refs/tags/<tagname> :

The way to interpret the above is to read it as the null value before the colon is being pushed to the remote tag name, effectively deleting it.

The second (and more intuitive) way to delete a remote tag is with:

Checking out Tags

If you want to view the versions of files a tag is pointing to, you can do a git checkout of that tag, although this puts your repository in “detached HEAD” state, which has some ill side effects:

In “detached HEAD” state, if you make changes and then create a commit, the tag will stay the same, but your new commit won’t belong to any branch and will be unreachable, except by the exact commit hash. Thus, if you need to make changes — say you’re fixing a bug on an older version, for instance — you will generally want to create a branch:

If you do this and make a commit, your version2 branch will be slightly different than your v2.0.0 tag since it will move forward with your new changes, so do be careful.


Porting to Python 2.6¶

This section lists previously described changes and other bugfixes that may require changes to your code:

Classes that aren’t supposed to be hashable should set __hash__ = None in their definitions to indicate the fact.

String exceptions have been removed. Attempting to use them raises a TypeError .

The __init__() method of collections.deque now clears any existing contents of the deque before adding elements from the iterable. This change makes the behavior match list.__init__() .

object.__init__() previously accepted arbitrary arguments and keyword arguments, ignoring them. In Python 2.6, this is no longer allowed and will result in a TypeError . This will affect __init__() methods that end up calling the corresponding method on object (perhaps through using super() ). See bpo-1683368 for discussion.

The Decimal constructor now accepts leading and trailing whitespace when passed a string. Previously it would raise an InvalidOperation exception. On the other hand, the create_decimal() method of Context objects now explicitly disallows extra whitespace, raising a ConversionSyntax exception.

Due to an implementation accident, if you passed a file path to the built-in __import__() function, it would actually import the specified file. This was never intended to work, however, and the implementation now explicitly checks for this case and raises an ImportError .

C API: the PyImport_Import() and PyImport_ImportModule() functions now default to absolute imports, not relative imports. This will affect C extensions that import other modules.

C API: extension data types that shouldn’t be hashable should define their tp_hash slot to PyObject_HashNotImplemented() .

The socket module exception socket.error now inherits from IOError . Previously it wasn’t a subclass of StandardError but now it is, through IOError . (Implemented by Gregory P. Smith bpo-1706815.)

The xmlrpclib module no longer automatically converts datetime.date and datetime.time to the xmlrpclib.DateTime type the conversion semantics were not necessarily correct for all applications. Code using xmlrpclib should convert date and time instances. (bpo-1330538)

(3.0-warning mode) The Exception class now warns when accessed using slicing or index access having Exception behave like a tuple is being phased out.

(3.0-warning mode) inequality comparisons between two dictionaries or two objects that don’t implement comparison methods are reported as warnings. dict1 == dict2 still works, but dict1 < dict2 is being phased out.

Comparisons between cells, which are an implementation detail of Python’s scoping rules, also cause warnings because such comparisons are forbidden entirely in 3.0.