This file is indexed.

/usr/share/doc/python-bottle-doc/html/configuration.html is in python-bottle-doc 0.12.7-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">


<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>Configuration (DRAFT) &mdash; Bottle 0.12.7 documentation</title>
    
    <link rel="stylesheet" href="_static/default.css" type="text/css" />
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
    
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    './',
        VERSION:     '0.12.7',
        COLLAPSE_INDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
      };
    </script>
    <script type="text/javascript" src="_static/jquery.js"></script>
    <script type="text/javascript" src="_static/underscore.js"></script>
    <script type="text/javascript" src="_static/doctools.js"></script>
    <link rel="top" title="Bottle 0.12.7 documentation" href="index.html" />
    <link rel="next" title="Request Routing" href="routing.html" />
    <link rel="prev" title="Tutorial" href="tutorial.html" /> 
  </head>
  <body>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="routing.html" title="Request Routing"
             accesskey="N">next</a> |</li>
        <li class="right" >
          <a href="tutorial.html" title="Tutorial"
             accesskey="P">previous</a> |</li>
        <li><a href="index.html">Bottle 0.12.7 documentation</a> &raquo;</li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body">
            
  <div class="section" id="configuration-draft">
<h1>Configuration (DRAFT)<a class="headerlink" href="#configuration-draft" title="Permalink to this headline"></a></h1>
<p>Bottle applications can store their configuration in <a class="reference internal" href="api.html#bottle.Bottle.config" title="bottle.Bottle.config"><tt class="xref py py-attr docutils literal"><span class="pre">Bottle.config</span></tt></a>, a dict-like object and central place for application specific settings. This dictionary controls many aspects of the framework, tells (newer) plugins what to do, and can be used to store your own configuration as well.</p>
<div class="section" id="configuration-basics">
<h2>Configuration Basics<a class="headerlink" href="#configuration-basics" title="Permalink to this headline"></a></h2>
<p>The <a class="reference internal" href="api.html#bottle.Bottle.config" title="bottle.Bottle.config"><tt class="xref py py-attr docutils literal"><span class="pre">Bottle.config</span></tt></a> object behaves a lot like an ordinary dictionary. All the common dict methods work as expected. Let us start with some examples:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="kn">import</span> <span class="nn">bottle</span>
<span class="n">app</span> <span class="o">=</span> <span class="n">bottle</span><span class="o">.</span><span class="n">default_app</span><span class="p">()</span>             <span class="c"># or bottle.Bottle() if you prefer</span>

<span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="p">[</span><span class="s">&#39;autojson&#39;</span><span class="p">]</span>    <span class="o">=</span> <span class="bp">False</span>      <span class="c"># Turns off the &quot;autojson&quot; feature</span>
<span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="p">[</span><span class="s">&#39;sqlite.db&#39;</span><span class="p">]</span>   <span class="o">=</span> <span class="s">&#39;:memory:&#39;</span> <span class="c"># Tells the sqlite plugin which db to use</span>
<span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="p">[</span><span class="s">&#39;myapp.param&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s">&#39;value&#39;</span>    <span class="c"># Example for a custom config value.</span>

<span class="c"># Change many values at once</span>
<span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="o">.</span><span class="n">update</span><span class="p">({</span>
    <span class="s">&#39;autojson&#39;</span><span class="p">:</span> <span class="bp">False</span><span class="p">,</span>
    <span class="s">&#39;sqlite.db&#39;</span><span class="p">:</span> <span class="s">&#39;:memory:&#39;</span><span class="p">,</span>
    <span class="s">&#39;myapp.param&#39;</span><span class="p">:</span> <span class="s">&#39;value&#39;</span>
<span class="p">})</span>

<span class="c"># Add default values</span>
<span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="o">.</span><span class="n">setdefault</span><span class="p">(</span><span class="s">&#39;myapp.param2&#39;</span><span class="p">,</span> <span class="s">&#39;some default&#39;</span><span class="p">)</span>

<span class="c"># Receive values</span>
<span class="n">param</span>  <span class="o">=</span> <span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="p">[</span><span class="s">&#39;myapp.param&#39;</span><span class="p">]</span>
<span class="n">param2</span> <span class="o">=</span> <span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s">&#39;myapp.param2&#39;</span><span class="p">,</span> <span class="s">&#39;fallback value&#39;</span><span class="p">)</span>

<span class="c"># An example route using configuration values</span>
<span class="nd">@app.route</span><span class="p">(</span><span class="s">&#39;/about&#39;</span><span class="p">,</span> <span class="n">view</span><span class="o">=</span><span class="s">&#39;about.rst&#39;</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">about</span><span class="p">():</span>
    <span class="n">email</span> <span class="o">=</span> <span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s">&#39;my.email&#39;</span><span class="p">,</span> <span class="s">&#39;nomail@example.com&#39;</span><span class="p">)</span>
    <span class="k">return</span> <span class="p">{</span><span class="s">&#39;email&#39;</span><span class="p">:</span> <span class="n">email</span><span class="p">}</span>
</pre></div>
</div>
<p>The app object is not always available, but as long as you are within a request context, you can use the <cite>request</cite> object to get the current application and its configuration:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="kn">from</span> <span class="nn">bottle</span> <span class="kn">import</span> <span class="n">request</span>
<span class="k">def</span> <span class="nf">is_admin</span><span class="p">(</span><span class="n">user</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">user</span> <span class="o">==</span> <span class="n">request</span><span class="o">.</span><span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="p">[</span><span class="s">&#39;myapp.admin_user&#39;</span><span class="p">]</span>
</pre></div>
</div>
</div>
<div class="section" id="naming-convention">
<h2>Naming Convention<a class="headerlink" href="#naming-convention" title="Permalink to this headline"></a></h2>
<p>To make life easier, plugins and applications should follow some simple rules when it comes to config parameter names:</p>
<ul class="simple">
<li>All keys should be lowercase strings and follow the rules for python identifiers (no special characters but the underscore).</li>
<li>Namespaces are separated by dots (e.g. <tt class="docutils literal"><span class="pre">namespace.field</span></tt> or <tt class="docutils literal"><span class="pre">namespace.subnamespace.field</span></tt>).</li>
<li>Bottle uses the root namespace for its own configuration. Plugins should store all their variables in their own namespace (e.g. <tt class="docutils literal"><span class="pre">sqlite.db</span></tt> or <tt class="docutils literal"><span class="pre">werkzeug.use_debugger</span></tt>).</li>
<li>Your own application should use a separate namespace (e.g. <tt class="docutils literal"><span class="pre">myapp.*</span></tt>).</li>
</ul>
</div>
<div class="section" id="loading-configuration-from-a-file">
<h2>Loading Configuration from a File<a class="headerlink" href="#loading-configuration-from-a-file" title="Permalink to this headline"></a></h2>
<p>Configuration files are useful if you want to enable non-programmers to configure your application,
or just don&#8217;t want to hack python module files just to change the database port. A very common syntax for configuration files is shown here:</p>
<div class="highlight-ini"><div class="highlight"><pre><span class="k">[bottle]</span>
<span class="na">debug</span> <span class="o">=</span> <span class="s">True</span>

<span class="k">[sqlite]</span>
<span class="na">db</span> <span class="o">=</span> <span class="s">/tmp/test.db</span>
<span class="na">commit</span> <span class="o">=</span> <span class="s">auto</span>

<span class="k">[myapp]</span>
<span class="na">admin_user</span> <span class="o">=</span> <span class="s">defnull</span>
</pre></div>
</div>
<p>With <a class="reference internal" href="#bottle.ConfigDict.load_config" title="bottle.ConfigDict.load_config"><tt class="xref py py-meth docutils literal"><span class="pre">ConfigDict.load_config()</span></tt></a> you can load these <tt class="docutils literal"><span class="pre">*.ini</span></tt> style configuration
files from disk and import their values into your existing configuration:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="o">.</span><span class="n">load_config</span><span class="p">(</span><span class="s">&#39;/etc/myapp.conf&#39;</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="section" id="loading-configuration-from-a-nested-dict">
<h2>Loading Configuration from a nested <tt class="xref py py-class docutils literal"><span class="pre">dict</span></tt><a class="headerlink" href="#loading-configuration-from-a-nested-dict" title="Permalink to this headline"></a></h2>
<p>Another useful method is <a class="reference internal" href="#bottle.ConfigDict.load_dict" title="bottle.ConfigDict.load_dict"><tt class="xref py py-meth docutils literal"><span class="pre">ConfigDict.load_dict()</span></tt></a>. This method takes
an entire structure of nested dictionaries and turns it into a flat list of keys and values with namespaced keys:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># Load an entire dict structure</span>
<span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="o">.</span><span class="n">load_dict</span><span class="p">({</span>
    <span class="s">&#39;autojson&#39;</span><span class="p">:</span> <span class="bp">False</span><span class="p">,</span>
    <span class="s">&#39;sqlite&#39;</span><span class="p">:</span> <span class="p">{</span> <span class="s">&#39;db&#39;</span><span class="p">:</span> <span class="s">&#39;:memory:&#39;</span> <span class="p">},</span>
    <span class="s">&#39;myapp&#39;</span><span class="p">:</span> <span class="p">{</span>
        <span class="s">&#39;param&#39;</span><span class="p">:</span> <span class="s">&#39;value&#39;</span><span class="p">,</span>
        <span class="s">&#39;param2&#39;</span><span class="p">:</span> <span class="s">&#39;value2&#39;</span>
    <span class="p">}</span>
<span class="p">})</span>

<span class="k">assert</span> <span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="p">[</span><span class="s">&#39;myapp.param&#39;</span><span class="p">]</span> <span class="o">==</span> <span class="s">&#39;value&#39;</span>

<span class="c"># Load configuration from a json file</span>
<span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s">&#39;/etc/myapp.json&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="n">fp</span><span class="p">:</span>
    <span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="o">.</span><span class="n">load_dict</span><span class="p">(</span><span class="n">json</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="n">fp</span><span class="p">))</span>
</pre></div>
</div>
</div>
<div class="section" id="listening-to-configuration-changes">
<h2>Listening to configuration changes<a class="headerlink" href="#listening-to-configuration-changes" title="Permalink to this headline"></a></h2>
<p>The <tt class="docutils literal"><span class="pre">config</span></tt> hook on the application object is triggered each time a value in <a class="reference internal" href="api.html#bottle.Bottle.config" title="bottle.Bottle.config"><tt class="xref py py-attr docutils literal"><span class="pre">Bottle.config</span></tt></a> is changed. This hook can be used to react on configuration changes at runtime, for example reconnect to a new database, change the debug settings on a background service or resize worker thread pools. The hook callback receives two arguments (key, new_value) and is called before the value is actually changed in the dictionary. Raising an exception from a hook callback cancels the change and the old value is preserved.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="nd">@app.hook</span><span class="p">(</span><span class="s">&#39;config&#39;</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">on_config_change</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
  <span class="k">if</span> <span class="n">key</span> <span class="o">==</span> <span class="s">&#39;debug&#39;</span><span class="p">:</span>
      <span class="n">switch_own_debug_mode_to</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
</pre></div>
</div>
<p>The hook callbacks cannot <em>change</em> the value that is to be stored to the dictionary. That is what filters are for.</p>
</div>
<div class="section" id="filters-and-other-meta-data">
<h2>Filters and other Meta Data<a class="headerlink" href="#filters-and-other-meta-data" title="Permalink to this headline"></a></h2>
<p><a class="reference internal" href="#bottle.ConfigDict" title="bottle.ConfigDict"><tt class="xref py py-class docutils literal"><span class="pre">ConfigDict</span></tt></a> allows you to store meta data along with configuration keys. Two meta fields are currently defined:</p>
<dl class="docutils">
<dt>help</dt>
<dd>A help or description string. May be used by debugging, introspection or
admin tools to help the site maintainer configuring their application.</dd>
<dt>filter</dt>
<dd>A callable that accepts and returns a single value. If a filter is defined for a key, any new value stored to that key is first passed through the filter callback. The filter can be used to cast the value to a different type, check for invalid values (throw a ValueError) or trigger side effects.</dd>
</dl>
<p>This feature is most useful for plugins. They can validate their config parameters or trigger side effects using filters and document their configuration via <tt class="docutils literal"><span class="pre">help</span></tt> fields:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">SomePlugin</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">setup</span><span class="p">(</span><span class="n">app</span><span class="p">):</span>
        <span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="o">.</span><span class="n">meta_set</span><span class="p">(</span><span class="s">&#39;some.int&#39;</span><span class="p">,</span> <span class="s">&#39;filter&#39;</span><span class="p">,</span> <span class="nb">int</span><span class="p">)</span>
        <span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="o">.</span><span class="n">meta_set</span><span class="p">(</span><span class="s">&#39;some.list&#39;</span><span class="p">,</span> <span class="s">&#39;filter&#39;</span><span class="p">,</span>
            <span class="k">lambda</span> <span class="n">val</span><span class="p">:</span> <span class="nb">str</span><span class="p">(</span><span class="n">val</span><span class="p">)</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s">&#39;;&#39;</span><span class="p">))</span>
        <span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="o">.</span><span class="n">meta_set</span><span class="p">(</span><span class="s">&#39;some.list&#39;</span><span class="p">,</span> <span class="s">&#39;help&#39;</span><span class="p">,</span>
            <span class="s">&#39;A semicolon separated list.&#39;</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">apply</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">callback</span><span class="p">,</span> <span class="n">route</span><span class="p">):</span>
        <span class="o">...</span>

<span class="kn">import</span> <span class="nn">bottle</span>
<span class="n">app</span> <span class="o">=</span> <span class="n">bottle</span><span class="o">.</span><span class="n">default_app</span><span class="p">()</span>
<span class="n">app</span><span class="o">.</span><span class="n">install</span><span class="p">(</span><span class="n">SomePlugin</span><span class="p">())</span>

<span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="p">[</span><span class="s">&#39;some.list&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s">&#39;a;b;c&#39;</span>     <span class="c"># Actually stores [&#39;a&#39;, &#39;b&#39;, &#39;c&#39;]</span>
<span class="n">app</span><span class="o">.</span><span class="n">config</span><span class="p">[</span><span class="s">&#39;some.int&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s">&#39;not an int&#39;</span> <span class="c"># raises ValueError</span>
</pre></div>
</div>
</div>
<div class="section" id="api-documentation">
<h2>API Documentation<a class="headerlink" href="#api-documentation" title="Permalink to this headline"></a></h2>
<dl class="class">
<dt id="bottle.ConfigDict">
<em class="property">class </em><tt class="descname">ConfigDict</tt><big>(</big><em>*a</em>, <em>**ka</em><big>)</big><a class="reference internal" href="_modules/bottle.html#ConfigDict"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#bottle.ConfigDict" title="Permalink to this definition"></a></dt>
<dd><p>A dict-like configuration storage with additional support for
namespaces, validators, meta-data, on_change listeners and more.</p>
<p>This storage is optimized for fast read access. Retrieving a key
or using non-altering dict methods (e.g. <cite>dict.get()</cite>) has no overhead
compared to a native dict.</p>
<dl class="method">
<dt id="bottle.ConfigDict.load_config">
<tt class="descname">load_config</tt><big>(</big><em>filename</em><big>)</big><a class="reference internal" href="_modules/bottle.html#ConfigDict.load_config"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#bottle.ConfigDict.load_config" title="Permalink to this definition"></a></dt>
<dd><p>Load values from an <a href="#id1"><span class="problematic" id="id2">*</span></a>.ini style config file.</p>
<p>If the config file contains sections, their names are used as
namespaces for the values within. The two special sections
<tt class="docutils literal"><span class="pre">DEFAULT</span></tt> and <tt class="docutils literal"><span class="pre">bottle</span></tt> refer to the root namespace (no prefix).</p>
</dd></dl>

<dl class="method">
<dt id="bottle.ConfigDict.load_dict">
<tt class="descname">load_dict</tt><big>(</big><em>source</em>, <em>namespace=''</em>, <em>make_namespaces=False</em><big>)</big><a class="reference internal" href="_modules/bottle.html#ConfigDict.load_dict"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#bottle.ConfigDict.load_dict" title="Permalink to this definition"></a></dt>
<dd><p>Import values from a dictionary structure. Nesting can be used to
represent namespaces.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">&gt;&gt;&gt; </span><span class="n">ConfigDict</span><span class="p">()</span><span class="o">.</span><span class="n">load_dict</span><span class="p">({</span><span class="s">&#39;name&#39;</span><span class="p">:</span> <span class="p">{</span><span class="s">&#39;space&#39;</span><span class="p">:</span> <span class="p">{</span><span class="s">&#39;key&#39;</span><span class="p">:</span> <span class="s">&#39;value&#39;</span><span class="p">}}})</span>
<span class="go">{&#39;name.space.key&#39;: &#39;value&#39;}</span>
</pre></div>
</div>
</dd></dl>

<dl class="method">
<dt id="bottle.ConfigDict.update">
<tt class="descname">update</tt><big>(</big><em>*a</em>, <em>**ka</em><big>)</big><a class="reference internal" href="_modules/bottle.html#ConfigDict.update"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#bottle.ConfigDict.update" title="Permalink to this definition"></a></dt>
<dd><p>If the first parameter is a string, all keys are prefixed with this
namespace. Apart from that it works just as the usual dict.update().
Example: <tt class="docutils literal"><span class="pre">update('some.namespace',</span> <span class="pre">key='value')</span></tt></p>
</dd></dl>

<dl class="method">
<dt id="bottle.ConfigDict.meta_get">
<tt class="descname">meta_get</tt><big>(</big><em>key</em>, <em>metafield</em>, <em>default=None</em><big>)</big><a class="reference internal" href="_modules/bottle.html#ConfigDict.meta_get"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#bottle.ConfigDict.meta_get" title="Permalink to this definition"></a></dt>
<dd><p>Return the value of a meta field for a key.</p>
</dd></dl>

<dl class="method">
<dt id="bottle.ConfigDict.meta_set">
<tt class="descname">meta_set</tt><big>(</big><em>key</em>, <em>metafield</em>, <em>value</em><big>)</big><a class="reference internal" href="_modules/bottle.html#ConfigDict.meta_set"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#bottle.ConfigDict.meta_set" title="Permalink to this definition"></a></dt>
<dd><p>Set the meta field for a key to a new value. This triggers the
on-change handler for existing keys.</p>
</dd></dl>

<dl class="method">
<dt id="bottle.ConfigDict.meta_list">
<tt class="descname">meta_list</tt><big>(</big><em>key</em><big>)</big><a class="reference internal" href="_modules/bottle.html#ConfigDict.meta_list"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#bottle.ConfigDict.meta_list" title="Permalink to this definition"></a></dt>
<dd><p>Return an iterable of meta field names defined for a key.</p>
</dd></dl>

</dd></dl>

</div>
</div>


          </div>
        </div>
      </div>
      <div class="sphinxsidebar">
        <div class="sphinxsidebarwrapper">
  <h3><a href="index.html">Table Of Contents</a></h3>
  <ul>
<li><a class="reference internal" href="#">Configuration (DRAFT)</a><ul>
<li><a class="reference internal" href="#configuration-basics">Configuration Basics</a></li>
<li><a class="reference internal" href="#naming-convention">Naming Convention</a></li>
<li><a class="reference internal" href="#loading-configuration-from-a-file">Loading Configuration from a File</a></li>
<li><a class="reference internal" href="#loading-configuration-from-a-nested-dict">Loading Configuration from a nested <tt class="docutils literal"><span class="pre">dict</span></tt></a></li>
<li><a class="reference internal" href="#listening-to-configuration-changes">Listening to configuration changes</a></li>
<li><a class="reference internal" href="#filters-and-other-meta-data">Filters and other Meta Data</a></li>
<li><a class="reference internal" href="#api-documentation">API Documentation</a></li>
</ul>
</li>
</ul>

  <h4>Previous topic</h4>
  <p class="topless"><a href="tutorial.html"
                        title="previous chapter">Tutorial</a></p>
  <h4>Next topic</h4>
  <p class="topless"><a href="routing.html"
                        title="next chapter">Request Routing</a></p>
  <h3>This Page</h3>
  <ul class="this-page-menu">
    <li><a href="_sources/configuration.txt"
           rel="nofollow">Show Source</a></li>
  </ul>
<div id="searchbox" style="display: none">
  <h3>Quick search</h3>
    <form class="search" action="search.html" method="get">
      <input type="text" name="q" />
      <input type="submit" value="Go" />
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>
    <p class="searchtip" style="font-size: 90%">
    Enter search terms or a module, class or function name.
    </p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="routing.html" title="Request Routing"
             >next</a> |</li>
        <li class="right" >
          <a href="tutorial.html" title="Tutorial"
             >previous</a> |</li>
        <li><a href="index.html">Bottle 0.12.7 documentation</a> &raquo;</li> 
      </ul>
    </div>
    <div class="footer">
        &copy; Copyright 2009-2014, Marcel Hellkamp.
      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.2.
    </div>
  </body>
</html>