1 files changed, 271 insertions, 0 deletions
diff --git a/docs/_locale/fr/LC_MESSAGES/stpl.po b/docs/_locale/fr/LC_MESSAGES/stpl.po
new file mode 100644
index 0000000..4608907
--- /dev/null
+++ b/docs/_locale/fr/LC_MESSAGES/stpl.po
@@ -0,0 +1,271 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2009-2020, Marcel Hellkamp
+# This file is distributed under the same license as the Bottle package.
+# 
+# Translators:
+msgid ""
+msgstr ""
+"Project-Id-Version: bottle\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-12-31 18:35+0100\n"
+"PO-Revision-Date: 2020-12-31 17:35+0000\n"
+"Last-Translator: defnull <marc@gsites.de>\n"
+"Language-Team: French (http://www.transifex.com/bottle/bottle/language/fr/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: fr\n"
+"Plural-Forms: nplurals=2; plural=(n > 1);\n"
+
+#: ../../stpl.rst:3
+msgid "SimpleTemplate Engine"
+msgstr ""
+
+#: ../../stpl.rst:7
+msgid ""
+"Bottle comes with a fast, powerful and easy to learn built-in template "
+"engine called *SimpleTemplate* or *stpl* for short. It is the default engine"
+" used by the :func:`view` and :func:`template` helpers but can be used as a "
+"stand-alone general purpose template engine too. This document explains the "
+"template syntax and shows examples for common use cases."
+msgstr ""
+
+#: ../../stpl.rst:10
+msgid "Basic API Usage:"
+msgstr ""
+
+#: ../../stpl.rst:11
+msgid ":class:`SimpleTemplate` implements the :class:`BaseTemplate` API::"
+msgstr ""
+
+#: ../../stpl.rst:18
+msgid ""
+"In this document we use the :func:`template` helper in examples for the sake"
+" of simplicity::"
+msgstr ""
+
+#: ../../stpl.rst:24
+msgid ""
+"You can also pass a dictionary into the template using keyword arguments::"
+msgstr ""
+
+#: ../../stpl.rst:31
+msgid ""
+"Just keep in mind that compiling and rendering templates are two different "
+"actions, even if the :func:`template` helper hides this fact. Templates are "
+"usually compiled only once and cached internally, but rendered many times "
+"with different keyword arguments."
+msgstr ""
+
+#: ../../stpl.rst:34
+msgid ":class:`SimpleTemplate` Syntax"
+msgstr ""
+
+#: ../../stpl.rst:36
+msgid ""
+"Python is a very powerful language but its whitespace-aware syntax makes it "
+"difficult to use as a template language. SimpleTemplate removes some of "
+"these restrictions and allows you to write clean, readable and maintainable "
+"templates while preserving full access to the features, libraries and speed "
+"of the Python language."
+msgstr ""
+
+#: ../../stpl.rst:40
+msgid ""
+"The :class:`SimpleTemplate` syntax compiles directly to python bytecode and "
+"is executed on each :meth:`SimpleTemplate.render` call. Do not render "
+"untrusted templates! They may contain and execute harmful python code."
+msgstr ""
+
+#: ../../stpl.rst:43
+msgid "Inline Expressions"
+msgstr ""
+
+#: ../../stpl.rst:45
+msgid ""
+"You already learned the use of the ``{{...}}`` syntax from the \"Hello "
+"World!\" example above, but there is more: any python expression is allowed "
+"within the curly brackets as long as it evaluates to a string or something "
+"that has a string representation::"
+msgstr ""
+
+#: ../../stpl.rst:54
+msgid ""
+"The contained python expression is executed at render-time and has access to"
+" all keyword arguments passed to the :meth:`SimpleTemplate.render` method. "
+"HTML special characters are escaped automatically to prevent `XSS "
+"<http://en.wikipedia.org/wiki/Cross-Site_Scripting>`_ attacks. You can start"
+" the expression with an exclamation mark to disable escaping for that "
+"expression::"
+msgstr ""
+
+#: ../../stpl.rst:62
+msgid "Embedded python code"
+msgstr ""
+
+#: ../../stpl.rst:66
+msgid ""
+"The template engine allows you to embed lines or blocks of python code "
+"within your template. Code lines start with ``%`` and code blocks are "
+"surrounded by ``<%`` and ``%>`` tokens::"
+msgstr ""
+
+#: ../../stpl.rst:76
+msgid ""
+"Embedded python code follows regular python syntax, but with two additional "
+"syntax rules:"
+msgstr ""
+
+#: ../../stpl.rst:78
+msgid ""
+"**Indentation is ignored.** You can put as much whitespace in front of "
+"statements as you want. This allows you to align your code with the "
+"surrounding markup and can greatly improve readability."
+msgstr ""
+
+#: ../../stpl.rst:79
+msgid ""
+"Blocks that are normally indented now have to be closed explicitly with an "
+"``end`` keyword."
+msgstr ""
+
+#: ../../stpl.rst:89
+msgid ""
+"Both the ``%`` and the ``<%`` tokens are only recognized if they are the "
+"first non-whitespace characters in a line. You don't have to escape them if "
+"they appear mid-text in your template markup. Only if a line of text starts "
+"with one of these tokens, you have to escape it with a backslash. In the "
+"rare case where the backslash + token combination appears in your markup at "
+"the beginning of a line, you can always help yourself with a string literal "
+"in an inline expression::"
+msgstr ""
+
+#: ../../stpl.rst:96
+msgid ""
+"If you find yourself needing to escape a lot, consider using :ref:`custom "
+"tokens <stpl-custom-tokens>`."
+msgstr ""
+
+#: ../../stpl.rst:98
+msgid ""
+"Note that ``%`` and ``<% %>`` work in *exactly* the same way. The latter is "
+"only a convenient way to type less and avoid clutter for longer code "
+"segments. This means that in ``<% %>`` blocks, all indented code must be "
+"terminated with an ``end``, as in the following example::"
+msgstr ""
+
+#: ../../stpl.rst:114
+msgid "Whitespace Control"
+msgstr ""
+
+#: ../../stpl.rst:116
+msgid ""
+"Code blocks and code lines always span the whole line. Whitespace in front "
+"of after a code segment is stripped away. You won't see empty lines or "
+"dangling whitespace in your template because of embedded code::"
+msgstr ""
+
+#: ../../stpl.rst:124
+msgid "This snippet renders to clean and compact html::"
+msgstr ""
+
+#: ../../stpl.rst:130
+msgid ""
+"But embedding code still requires you to start a new line, which may not "
+"what you want to see in your rendered template. To skip the newline in front"
+" of a code segment, end the text line with a double-backslash::"
+msgstr ""
+
+#: ../../stpl.rst:138
+msgid "This time the rendered template looks like this::"
+msgstr ""
+
+#: ../../stpl.rst:142
+msgid ""
+"This only works directly in front of code segments. In all other places you "
+"can control the whitespace yourself and don't need any special syntax."
+msgstr ""
+
+#: ../../stpl.rst:145
+msgid "Template Functions"
+msgstr ""
+
+#: ../../stpl.rst:147
+msgid ""
+"Each template is preloaded with a bunch of functions that help with the most"
+" common use cases. These functions are always available. You don't have to "
+"import or provide them yourself. For everything not covered here there are "
+"probably good python libraries available. Remember that you can ``import`` "
+"anything you want within your templates. They are python programs after all."
+msgstr ""
+
+#: ../../stpl.rst:151
+msgid ""
+"Prior to this release, :func:`include` and :func:`rebase` were syntax "
+"keywords, not functions."
+msgstr ""
+
+#: ../../stpl.rst:156
+msgid ""
+"Render a sub-template with the specified variables and insert the resulting "
+"text into the current template. The function returns a dictionary containing"
+" the local variables passed to or defined within the sub-template::"
+msgstr ""
+
+#: ../../stpl.rst:164
+msgid ""
+"Mark the current template to be later included into a different template. "
+"After the current template is rendered, its resulting text is stored in a "
+"variable named ``base`` and passed to the base-template, which is then "
+"rendered. This can be used to `wrap` a template with surrounding text, or "
+"simulate the inheritance feature found in other template engines::"
+msgstr ""
+
+#: ../../stpl.rst:169
+msgid "This can be combined with the following ``base.tpl``::"
+msgstr ""
+
+#: ../../stpl.rst:181
+msgid ""
+"Accessing undefined variables in a template raises :exc:`NameError` and "
+"stops rendering immediately. This is standard python behavior and nothing "
+"new, but vanilla python lacks an easy way to check the availability of a "
+"variable. This quickly gets annoying if you want to support flexible inputs "
+"or use the same template in different situations. These functions may help:"
+msgstr ""
+
+#: ../../stpl.rst:189
+msgid ""
+"Return True if the variable is defined in the current template namespace, "
+"False otherwise."
+msgstr ""
+
+#: ../../stpl.rst:194
+msgid "Return the variable, or a default value."
+msgstr ""
+
+#: ../../stpl.rst:198
+msgid ""
+"If the variable is not defined, create it with the given default value. "
+"Return the variable."
+msgstr ""
+
+#: ../../stpl.rst:201
+msgid ""
+"Here is an example that uses all three functions to implement optional "
+"template variables in different ways::"
+msgstr ""
+
+#: ../../stpl.rst:215
+msgid ":class:`SimpleTemplate` API"
+msgstr ""
+
+#: ../../../bottle.pydocstring of bottle.SimpleTemplate.prepare:1
+msgid ""
+"Run preparations (parsing, caching, ...). It should be possible to call this"
+" again to refresh a template or to update settings."
+msgstr ""
+
+#: ../../../bottle.pydocstring of bottle.SimpleTemplate.render:1
+msgid "Render the template using keyword arguments as local variables."
+msgstr ""