chendeben
/
ProxyPool


			
							1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782
							<!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" lang="en">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>werkzeug.datastructures &#8212; proxypool  documentation</title>
    
    <link rel="stylesheet" href="../../_static/alabaster.css" type="text/css" />
    <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
    
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '../../',
        VERSION:     '',
        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="index" title="Index" href="../../genindex.html" />
    <link rel="search" title="Search" href="../../search.html" />
    <link rel="top" title="proxypool  documentation" href="../../index.html" />
    <link rel="up" title="Module code" href="../index.html" />
   
  <link rel="stylesheet" href="../../_static/custom.css" type="text/css" />
  
  
  <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />

  </head>
  <body role="document">
  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body" role="main">
            
  <h1>Source code for werkzeug.datastructures</h1><div class="highlight"><pre>
<span></span><span class="c1"># -*- coding: utf-8 -*-</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">    werkzeug.datastructures</span>
<span class="sd">    ~~~~~~~~~~~~~~~~~~~~~~~</span>

<span class="sd">    This module provides mixins and classes with an immutable interface.</span>

<span class="sd">    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.</span>
<span class="sd">    :license: BSD, see LICENSE for more details.</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="kn">import</span> <span class="nn">re</span>
<span class="kn">import</span> <span class="nn">codecs</span>
<span class="kn">import</span> <span class="nn">mimetypes</span>
<span class="kn">from</span> <span class="nn">copy</span> <span class="k">import</span> <span class="n">deepcopy</span>
<span class="kn">from</span> <span class="nn">itertools</span> <span class="k">import</span> <span class="n">repeat</span>

<span class="kn">from</span> <span class="nn">werkzeug._internal</span> <span class="k">import</span> <span class="n">_missing</span><span class="p">,</span> <span class="n">_empty_stream</span>
<span class="kn">from</span> <span class="nn">werkzeug._compat</span> <span class="k">import</span> <span class="n">iterkeys</span><span class="p">,</span> <span class="n">itervalues</span><span class="p">,</span> <span class="n">iteritems</span><span class="p">,</span> <span class="n">iterlists</span><span class="p">,</span> \
    <span class="n">PY2</span><span class="p">,</span> <span class="n">text_type</span><span class="p">,</span> <span class="n">integer_types</span><span class="p">,</span> <span class="n">string_types</span><span class="p">,</span> <span class="n">make_literal_wrapper</span><span class="p">,</span> \
    <span class="n">to_native</span>
<span class="kn">from</span> <span class="nn">werkzeug.filesystem</span> <span class="k">import</span> <span class="n">get_filesystem_encoding</span>


<span class="n">_locale_delim_re</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="s1">r&#39;[_-]&#39;</span><span class="p">)</span>


<span class="k">def</span> <span class="nf">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
    <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">&#39;</span><span class="si">%r</span><span class="s1"> objects are immutable&#39;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">)</span>


<span class="k">def</span> <span class="nf">iter_multi_items</span><span class="p">(</span><span class="n">mapping</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;Iterates over the items of a mapping yielding keys and values</span>
<span class="sd">    without dropping any from more complex structures.</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">mapping</span><span class="p">,</span> <span class="n">MultiDict</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="n">mapping</span><span class="p">,</span> <span class="n">multi</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
            <span class="k">yield</span> <span class="n">item</span>
    <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">mapping</span><span class="p">,</span> <span class="nb">dict</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="n">mapping</span><span class="p">):</span>
            <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="p">(</span><span class="nb">tuple</span><span class="p">,</span> <span class="nb">list</span><span class="p">)):</span>
                <span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">value</span><span class="p">:</span>
                    <span class="k">yield</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="k">yield</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">mapping</span><span class="p">:</span>
            <span class="k">yield</span> <span class="n">item</span>


<span class="k">def</span> <span class="nf">native_itermethods</span><span class="p">(</span><span class="n">names</span><span class="p">):</span>
    <span class="k">if</span> <span class="ow">not</span> <span class="n">PY2</span><span class="p">:</span>
        <span class="k">return</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span>

    <span class="k">def</span> <span class="nf">setmethod</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
        <span class="n">itermethod</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>
        <span class="nb">setattr</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="s1">&#39;iter</span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="n">name</span><span class="p">,</span> <span class="n">itermethod</span><span class="p">)</span>
        <span class="n">listmethod</span> <span class="o">=</span> <span class="k">lambda</span> <span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">a</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">:</span> <span class="nb">list</span><span class="p">(</span><span class="n">itermethod</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">a</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">))</span>
        <span class="n">listmethod</span><span class="o">.</span><span class="n">__doc__</span> <span class="o">=</span> \
            <span class="s1">&#39;Like :py:meth:`iter</span><span class="si">%s</span><span class="s1">`, but returns a list.&#39;</span> <span class="o">%</span> <span class="n">name</span>
        <span class="nb">setattr</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">listmethod</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">wrap</span><span class="p">(</span><span class="n">cls</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">names</span><span class="p">:</span>
            <span class="n">setmethod</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">cls</span>
    <span class="k">return</span> <span class="n">wrap</span>


<span class="k">class</span> <span class="nc">ImmutableListMixin</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Makes a :class:`list` immutable.</span>

<span class="sd">    .. versionadded:: 0.5</span>

<span class="sd">    :private:</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="n">_hash_cache</span> <span class="o">=</span> <span class="kc">None</span>

    <span class="k">def</span> <span class="nf">__hash__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_hash_cache</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_hash_cache</span>
        <span class="n">rv</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_hash_cache</span> <span class="o">=</span> <span class="nb">hash</span><span class="p">(</span><span class="nb">tuple</span><span class="p">(</span><span class="bp">self</span><span class="p">))</span>
        <span class="k">return</span> <span class="n">rv</span>

    <span class="k">def</span> <span class="nf">__reduce_ex__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">protocol</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="p">),</span> <span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="bp">self</span><span class="p">),)</span>

    <span class="k">def</span> <span class="nf">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__delslice__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">j</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__iadd__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
    <span class="n">__imul__</span> <span class="o">=</span> <span class="n">__iadd__</span>

    <span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</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="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__setslice__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">j</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">append</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
    <span class="n">remove</span> <span class="o">=</span> <span class="n">append</span>

    <span class="k">def</span> <span class="nf">extend</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">iterable</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">insert</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">pos</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">index</span><span class="o">=-</span><span class="mi">1</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">reverse</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">sort</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="nb">cmp</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">reverse</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">ImmutableList</span><span class="p">(</span><span class="n">ImmutableListMixin</span><span class="p">,</span> <span class="nb">list</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;An immutable :class:`list`.</span>

<span class="sd">    .. versionadded:: 0.5</span>

<span class="sd">    :private:</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1">(</span><span class="si">%s</span><span class="s1">)&#39;</span> <span class="o">%</span> <span class="p">(</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span>
            <span class="nb">list</span><span class="o">.</span><span class="n">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">),</span>
        <span class="p">)</span>


<span class="k">class</span> <span class="nc">ImmutableDictMixin</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Makes a :class:`dict` immutable.</span>

<span class="sd">    .. versionadded:: 0.5</span>

<span class="sd">    :private:</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="n">_hash_cache</span> <span class="o">=</span> <span class="kc">None</span>

    <span class="nd">@classmethod</span>
    <span class="k">def</span> <span class="nf">fromkeys</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">keys</span><span class="p">,</span> <span class="n">value</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="n">instance</span> <span class="o">=</span> <span class="nb">super</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">cls</span><span class="p">)</span><span class="o">.</span><span class="n">__new__</span><span class="p">(</span><span class="n">cls</span><span class="p">)</span>
        <span class="n">instance</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="n">keys</span><span class="p">,</span> <span class="n">repeat</span><span class="p">(</span><span class="n">value</span><span class="p">)))</span>
        <span class="k">return</span> <span class="n">instance</span>

    <span class="k">def</span> <span class="nf">__reduce_ex__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">protocol</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="p">),</span> <span class="p">(</span><span class="nb">dict</span><span class="p">(</span><span class="bp">self</span><span class="p">),)</span>

    <span class="k">def</span> <span class="nf">_iter_hashitems</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__hash__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_hash_cache</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_hash_cache</span>
        <span class="n">rv</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_hash_cache</span> <span class="o">=</span> <span class="nb">hash</span><span class="p">(</span><span class="nb">frozenset</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_iter_hashitems</span><span class="p">()))</span>
        <span class="k">return</span> <span class="n">rv</span>

    <span class="k">def</span> <span class="nf">setdefault</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">popitem</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</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="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">ImmutableMultiDictMixin</span><span class="p">(</span><span class="n">ImmutableDictMixin</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Makes a :class:`MultiDict` immutable.</span>

<span class="sd">    .. versionadded:: 0.5</span>

<span class="sd">    :private:</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__reduce_ex__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">protocol</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="p">),</span> <span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">multi</span><span class="o">=</span><span class="kc">True</span><span class="p">)),)</span>

    <span class="k">def</span> <span class="nf">_iter_hashitems</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">multi</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">add</span><span class="p">(</span><span class="bp">self</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="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">popitemlist</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">poplist</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">setlist</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">new_list</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">setlistdefault</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default_list</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">UpdateDictMixin</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Makes dicts call `self.on_update` on modifications.</span>

<span class="sd">    .. versionadded:: 0.5</span>

<span class="sd">    :private:</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="n">on_update</span> <span class="o">=</span> <span class="kc">None</span>

    <span class="k">def</span> <span class="nf">calls_update</span><span class="p">(</span><span class="n">name</span><span class="p">):</span>
        <span class="k">def</span> <span class="nf">oncall</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">):</span>
            <span class="n">rv</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="nb">super</span><span class="p">(</span><span class="n">UpdateDictMixin</span><span class="p">,</span> <span class="bp">self</span><span class="p">),</span> <span class="n">name</span><span class="p">)(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">)</span>
            <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
            <span class="k">return</span> <span class="n">rv</span>
        <span class="n">oncall</span><span class="o">.</span><span class="n">__name__</span> <span class="o">=</span> <span class="n">name</span>
        <span class="k">return</span> <span class="n">oncall</span>

    <span class="k">def</span> <span class="nf">setdefault</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="n">modified</span> <span class="o">=</span> <span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="bp">self</span>
        <span class="n">rv</span> <span class="o">=</span> <span class="nb">super</span><span class="p">(</span><span class="n">UpdateDictMixin</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">setdefault</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">modified</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">rv</span>

    <span class="k">def</span> <span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="n">_missing</span><span class="p">):</span>
        <span class="n">modified</span> <span class="o">=</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span>
        <span class="k">if</span> <span class="n">default</span> <span class="ow">is</span> <span class="n">_missing</span><span class="p">:</span>
            <span class="n">rv</span> <span class="o">=</span> <span class="nb">super</span><span class="p">(</span><span class="n">UpdateDictMixin</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="n">rv</span> <span class="o">=</span> <span class="nb">super</span><span class="p">(</span><span class="n">UpdateDictMixin</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">modified</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">rv</span>

    <span class="n">__setitem__</span> <span class="o">=</span> <span class="n">calls_update</span><span class="p">(</span><span class="s1">&#39;__setitem__&#39;</span><span class="p">)</span>
    <span class="n">__delitem__</span> <span class="o">=</span> <span class="n">calls_update</span><span class="p">(</span><span class="s1">&#39;__delitem__&#39;</span><span class="p">)</span>
    <span class="n">clear</span> <span class="o">=</span> <span class="n">calls_update</span><span class="p">(</span><span class="s1">&#39;clear&#39;</span><span class="p">)</span>
    <span class="n">popitem</span> <span class="o">=</span> <span class="n">calls_update</span><span class="p">(</span><span class="s1">&#39;popitem&#39;</span><span class="p">)</span>
    <span class="n">update</span> <span class="o">=</span> <span class="n">calls_update</span><span class="p">(</span><span class="s1">&#39;update&#39;</span><span class="p">)</span>
    <span class="k">del</span> <span class="n">calls_update</span>


<span class="k">class</span> <span class="nc">TypeConversionDict</span><span class="p">(</span><span class="nb">dict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Works like a regular dict but the :meth:`get` method can perform</span>
<span class="sd">    type conversions.  :class:`MultiDict` and :class:`CombinedMultiDict`</span>
<span class="sd">    are subclasses of this class and provide the same feature.</span>

<span class="sd">    .. versionadded:: 0.5</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">get</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="nb">type</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return the default value if the requested data doesn&#39;t exist.</span>
<span class="sd">        If `type` is provided and is a callable it should convert the value,</span>
<span class="sd">        return it or raise a :exc:`ValueError` if that is not possible.  In</span>
<span class="sd">        this case the function will return the default as if the value was not</span>
<span class="sd">        found:</span>

<span class="sd">        &gt;&gt;&gt; d = TypeConversionDict(foo=&#39;42&#39;, bar=&#39;blub&#39;)</span>
<span class="sd">        &gt;&gt;&gt; d.get(&#39;foo&#39;, type=int)</span>
<span class="sd">        42</span>
<span class="sd">        &gt;&gt;&gt; d.get(&#39;bar&#39;, -1, type=int)</span>
<span class="sd">        -1</span>

<span class="sd">        :param key: The key to be looked up.</span>
<span class="sd">        :param default: The default value to be returned if the key can&#39;t</span>
<span class="sd">                        be looked up.  If not further specified `None` is</span>
<span class="sd">                        returned.</span>
<span class="sd">        :param type: A callable that is used to cast the value in the</span>
<span class="sd">                     :class:`MultiDict`.  If a :exc:`ValueError` is raised</span>
<span class="sd">                     by this callable the default value is returned.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">rv</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
            <span class="k">if</span> <span class="nb">type</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
                <span class="n">rv</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="n">rv</span><span class="p">)</span>
        <span class="k">except</span> <span class="p">(</span><span class="ne">KeyError</span><span class="p">,</span> <span class="ne">ValueError</span><span class="p">):</span>
            <span class="n">rv</span> <span class="o">=</span> <span class="n">default</span>
        <span class="k">return</span> <span class="n">rv</span>


<span class="k">class</span> <span class="nc">ImmutableTypeConversionDict</span><span class="p">(</span><span class="n">ImmutableDictMixin</span><span class="p">,</span> <span class="n">TypeConversionDict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Works like a :class:`TypeConversionDict` but does not support</span>
<span class="sd">    modifications.</span>

<span class="sd">    .. versionadded:: 0.5</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return a shallow mutable copy of this object.  Keep in mind that</span>
<span class="sd">        the standard library&#39;s :func:`copy` function is a no-op for this class</span>
<span class="sd">        like for any other python immutable type (eg: :class:`tuple`).</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="n">TypeConversionDict</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__copy__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span>


<span class="nd">@native_itermethods</span><span class="p">([</span><span class="s1">&#39;keys&#39;</span><span class="p">,</span> <span class="s1">&#39;values&#39;</span><span class="p">,</span> <span class="s1">&#39;items&#39;</span><span class="p">,</span> <span class="s1">&#39;lists&#39;</span><span class="p">,</span> <span class="s1">&#39;listvalues&#39;</span><span class="p">])</span>
<span class="k">class</span> <span class="nc">MultiDict</span><span class="p">(</span><span class="n">TypeConversionDict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;A :class:`MultiDict` is a dictionary subclass customized to deal with</span>
<span class="sd">    multiple values for the same key which is for example used by the parsing</span>
<span class="sd">    functions in the wrappers.  This is necessary because some HTML form</span>
<span class="sd">    elements pass multiple values for the same key.</span>

<span class="sd">    :class:`MultiDict` implements all standard dictionary methods.</span>
<span class="sd">    Internally, it saves all values for a key as a list, but the standard dict</span>
<span class="sd">    access methods will only return the first value for a key. If you want to</span>
<span class="sd">    gain access to the other values, too, you have to use the `list` methods as</span>
<span class="sd">    explained below.</span>

<span class="sd">    Basic Usage:</span>

<span class="sd">    &gt;&gt;&gt; d = MultiDict([(&#39;a&#39;, &#39;b&#39;), (&#39;a&#39;, &#39;c&#39;)])</span>
<span class="sd">    &gt;&gt;&gt; d</span>
<span class="sd">    MultiDict([(&#39;a&#39;, &#39;b&#39;), (&#39;a&#39;, &#39;c&#39;)])</span>
<span class="sd">    &gt;&gt;&gt; d[&#39;a&#39;]</span>
<span class="sd">    &#39;b&#39;</span>
<span class="sd">    &gt;&gt;&gt; d.getlist(&#39;a&#39;)</span>
<span class="sd">    [&#39;b&#39;, &#39;c&#39;]</span>
<span class="sd">    &gt;&gt;&gt; &#39;a&#39; in d</span>
<span class="sd">    True</span>

<span class="sd">    It behaves like a normal dict thus all dict functions will only return the</span>
<span class="sd">    first value when multiple values for one key are found.</span>

<span class="sd">    From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a</span>
<span class="sd">    subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will</span>
<span class="sd">    render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP</span>
<span class="sd">    exceptions.</span>

<span class="sd">    A :class:`MultiDict` can be constructed from an iterable of</span>
<span class="sd">    ``(key, value)`` tuples, a dict, a :class:`MultiDict` or from Werkzeug 0.2</span>
<span class="sd">    onwards some keyword parameters.</span>

<span class="sd">    :param mapping: the initial value for the :class:`MultiDict`.  Either a</span>
<span class="sd">                    regular dict, an iterable of ``(key, value)`` tuples</span>
<span class="sd">                    or `None`.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">mapping</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">mapping</span><span class="p">,</span> <span class="n">MultiDict</span><span class="p">):</span>
            <span class="nb">dict</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="p">((</span><span class="n">k</span><span class="p">,</span> <span class="n">l</span><span class="p">[:])</span> <span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">l</span> <span class="ow">in</span> <span class="n">iterlists</span><span class="p">(</span><span class="n">mapping</span><span class="p">)))</span>
        <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">mapping</span><span class="p">,</span> <span class="nb">dict</span><span class="p">):</span>
            <span class="n">tmp</span> <span class="o">=</span> <span class="p">{}</span>
            <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="n">mapping</span><span class="p">):</span>
                <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="p">(</span><span class="nb">tuple</span><span class="p">,</span> <span class="nb">list</span><span class="p">)):</span>
                    <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">value</span><span class="p">)</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
                        <span class="k">continue</span>
                    <span class="n">value</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
                <span class="k">else</span><span class="p">:</span>
                    <span class="n">value</span> <span class="o">=</span> <span class="p">[</span><span class="n">value</span><span class="p">]</span>
                <span class="n">tmp</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>
            <span class="nb">dict</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">tmp</span><span class="p">)</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="n">tmp</span> <span class="o">=</span> <span class="p">{}</span>
            <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">mapping</span> <span class="ow">or</span> <span class="p">():</span>
                <span class="n">tmp</span><span class="o">.</span><span class="n">setdefault</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="p">[])</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
            <span class="nb">dict</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">tmp</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__getstate__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">dict</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">lists</span><span class="p">())</span>

    <span class="k">def</span> <span class="nf">__setstate__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return the first data value for this key;</span>
<span class="sd">        raises KeyError if not found.</span>

<span class="sd">        :param key: The key to be looked up.</span>
<span class="sd">        :raise KeyError: if the key does not exist.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="n">lst</span> <span class="o">=</span> <span class="nb">dict</span><span class="o">.</span><span class="n">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
            <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">lst</span><span class="p">)</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">lst</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
        <span class="k">raise</span> <span class="n">exceptions</span><span class="o">.</span><span class="n">BadRequestKeyError</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</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="sd">&quot;&quot;&quot;Like :meth:`add` but removes an existing key first.</span>

<span class="sd">        :param key: the key for the value.</span>
<span class="sd">        :param value: the value to set.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="p">[</span><span class="n">value</span><span class="p">])</span>

    <span class="k">def</span> <span class="nf">add</span><span class="p">(</span><span class="bp">self</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="sd">&quot;&quot;&quot;Adds a new value for the key.</span>

<span class="sd">        .. versionadded:: 0.6</span>

<span class="sd">        :param key: the key for the value.</span>
<span class="sd">        :param value: the value to add.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">setdefault</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="p">[])</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">getlist</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="nb">type</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return the list of items for a given key. If that key is not in the</span>
<span class="sd">        `MultiDict`, the return value will be an empty list.  Just as `get`</span>
<span class="sd">        `getlist` accepts a `type` parameter.  All items will be converted</span>
<span class="sd">        with the callable defined there.</span>

<span class="sd">        :param key: The key to be looked up.</span>
<span class="sd">        :param type: A callable that is used to cast the value in the</span>
<span class="sd">                     :class:`MultiDict`.  If a :exc:`ValueError` is raised</span>
<span class="sd">                     by this callable the value will be removed from the list.</span>
<span class="sd">        :return: a :class:`list` of all the values for the key.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">rv</span> <span class="o">=</span> <span class="nb">dict</span><span class="o">.</span><span class="n">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
            <span class="k">return</span> <span class="p">[]</span>
        <span class="k">if</span> <span class="nb">type</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">return</span> <span class="nb">list</span><span class="p">(</span><span class="n">rv</span><span class="p">)</span>
        <span class="n">result</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">rv</span><span class="p">:</span>
            <span class="k">try</span><span class="p">:</span>
                <span class="n">result</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">item</span><span class="p">))</span>
            <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
                <span class="k">pass</span>
        <span class="k">return</span> <span class="n">result</span>

    <span class="k">def</span> <span class="nf">setlist</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">new_list</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Remove the old values for a key and add new ones.  Note that the list</span>
<span class="sd">        you pass the values in will be shallow-copied before it is inserted in</span>
<span class="sd">        the dictionary.</span>

<span class="sd">        &gt;&gt;&gt; d = MultiDict()</span>
<span class="sd">        &gt;&gt;&gt; d.setlist(&#39;foo&#39;, [&#39;1&#39;, &#39;2&#39;])</span>
<span class="sd">        &gt;&gt;&gt; d[&#39;foo&#39;]</span>
<span class="sd">        &#39;1&#39;</span>
<span class="sd">        &gt;&gt;&gt; d.getlist(&#39;foo&#39;)</span>
<span class="sd">        [&#39;1&#39;, &#39;2&#39;]</span>

<span class="sd">        :param key: The key for which the values are set.</span>
<span class="sd">        :param new_list: An iterable with the new values for the key.  Old values</span>
<span class="sd">                         are removed first.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="nb">list</span><span class="p">(</span><span class="n">new_list</span><span class="p">))</span>

    <span class="k">def</span> <span class="nf">setdefault</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Returns the value for the key if it is in the dict, otherwise it</span>
<span class="sd">        returns `default` and sets that value for `key`.</span>

<span class="sd">        :param key: The key to be looked up.</span>
<span class="sd">        :param default: The default value to be returned if the key is not</span>
<span class="sd">                        in the dict.  If not further specified it&#39;s `None`.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">default</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="n">default</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
        <span class="k">return</span> <span class="n">default</span>

    <span class="k">def</span> <span class="nf">setlistdefault</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default_list</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Like `setdefault` but sets multiple values.  The list returned</span>
<span class="sd">        is not a copy, but the list that is actually used internally.  This</span>
<span class="sd">        means that you can put new values into the dict by appending items</span>
<span class="sd">        to the list:</span>

<span class="sd">        &gt;&gt;&gt; d = MultiDict({&quot;foo&quot;: 1})</span>
<span class="sd">        &gt;&gt;&gt; d.setlistdefault(&quot;foo&quot;).extend([2, 3])</span>
<span class="sd">        &gt;&gt;&gt; d.getlist(&quot;foo&quot;)</span>
<span class="sd">        [1, 2, 3]</span>

<span class="sd">        :param key: The key to be looked up.</span>
<span class="sd">        :param default: An iterable of default values.  It is either copied</span>
<span class="sd">                        (in case it was a list) or converted into a list</span>
<span class="sd">                        before returned.</span>
<span class="sd">        :return: a :class:`list`</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="n">default_list</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">default_list</span> <span class="ow">or</span> <span class="p">())</span>
            <span class="nb">dict</span><span class="o">.</span><span class="n">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default_list</span><span class="p">)</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="n">default_list</span> <span class="o">=</span> <span class="nb">dict</span><span class="o">.</span><span class="n">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">default_list</span>

    <span class="k">def</span> <span class="nf">items</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">multi</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return an iterator of ``(key, value)`` pairs.</span>

<span class="sd">        :param multi: If set to `True` the iterator returned will have a pair</span>
<span class="sd">                      for each value of each key.  Otherwise it will only</span>
<span class="sd">                      contain pairs for the first value of each key.</span>
<span class="sd">        &quot;&quot;&quot;</span>

        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">values</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="nb">dict</span><span class="p">,</span> <span class="bp">self</span><span class="p">):</span>
            <span class="k">if</span> <span class="n">multi</span><span class="p">:</span>
                <span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">values</span><span class="p">:</span>
                    <span class="k">yield</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="k">yield</span> <span class="n">key</span><span class="p">,</span> <span class="n">values</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>

    <span class="k">def</span> <span class="nf">lists</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return a list of ``(key, values)`` pairs, where values is the list</span>
<span class="sd">        of all values associated with the key.&quot;&quot;&quot;</span>

        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">values</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="nb">dict</span><span class="p">,</span> <span class="bp">self</span><span class="p">):</span>
            <span class="k">yield</span> <span class="n">key</span><span class="p">,</span> <span class="nb">list</span><span class="p">(</span><span class="n">values</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">keys</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="n">iterkeys</span><span class="p">(</span><span class="nb">dict</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span>

    <span class="n">__iter__</span> <span class="o">=</span> <span class="n">keys</span>

    <span class="k">def</span> <span class="nf">values</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Returns an iterator of the first value on every key&#39;s value list.&quot;&quot;&quot;</span>
        <span class="k">for</span> <span class="n">values</span> <span class="ow">in</span> <span class="n">itervalues</span><span class="p">(</span><span class="nb">dict</span><span class="p">,</span> <span class="bp">self</span><span class="p">):</span>
            <span class="k">yield</span> <span class="n">values</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>

    <span class="k">def</span> <span class="nf">listvalues</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return an iterator of all values associated with a key.  Zipping</span>
<span class="sd">        :meth:`keys` and this is the same as calling :meth:`lists`:</span>

<span class="sd">        &gt;&gt;&gt; d = MultiDict({&quot;foo&quot;: [1, 2, 3]})</span>
<span class="sd">        &gt;&gt;&gt; zip(d.keys(), d.listvalues()) == d.lists()</span>
<span class="sd">        True</span>
<span class="sd">        &quot;&quot;&quot;</span>

        <span class="k">return</span> <span class="n">itervalues</span><span class="p">(</span><span class="nb">dict</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return a shallow copy of this object.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">deepcopy</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">memo</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return a deep copy of this object.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="p">(</span><span class="n">deepcopy</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">to_dict</span><span class="p">(</span><span class="n">flat</span><span class="o">=</span><span class="kc">False</span><span class="p">),</span> <span class="n">memo</span><span class="p">))</span>

    <span class="k">def</span> <span class="nf">to_dict</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">flat</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return the contents as regular dict.  If `flat` is `True` the</span>
<span class="sd">        returned dict will only have the first item present, if `flat` is</span>
<span class="sd">        `False` all values will be returned as lists.</span>

<span class="sd">        :param flat: If set to `False` the dict returned will have lists</span>
<span class="sd">                     with all the values in it.  Otherwise it will only</span>
<span class="sd">                     contain the first value for each key.</span>
<span class="sd">        :return: a :class:`dict`</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="n">flat</span><span class="p">:</span>
            <span class="k">return</span> <span class="nb">dict</span><span class="p">(</span><span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">))</span>
        <span class="k">return</span> <span class="nb">dict</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">lists</span><span class="p">())</span>

    <span class="k">def</span> <span class="nf">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other_dict</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;update() extends rather than replaces existing key lists:</span>

<span class="sd">        &gt;&gt;&gt; a = MultiDict({&#39;x&#39;: 1})</span>
<span class="sd">        &gt;&gt;&gt; b = MultiDict({&#39;x&#39;: 2, &#39;y&#39;: 3})</span>
<span class="sd">        &gt;&gt;&gt; a.update(b)</span>
<span class="sd">        &gt;&gt;&gt; a</span>
<span class="sd">        MultiDict([(&#39;y&#39;, 3), (&#39;x&#39;, 1), (&#39;x&#39;, 2)])</span>

<span class="sd">        If the value list for a key in ``other_dict`` is empty, no new values</span>
<span class="sd">        will be added to the dict and the key will not be created:</span>

<span class="sd">        &gt;&gt;&gt; x = {&#39;empty_list&#39;: []}</span>
<span class="sd">        &gt;&gt;&gt; y = MultiDict()</span>
<span class="sd">        &gt;&gt;&gt; y.update(x)</span>
<span class="sd">        &gt;&gt;&gt; y</span>
<span class="sd">        MultiDict([])</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iter_multi_items</span><span class="p">(</span><span class="n">other_dict</span><span class="p">):</span>
            <span class="n">MultiDict</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="bp">self</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">def</span> <span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="n">_missing</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Pop the first item for a list on the dict.  Afterwards the</span>
<span class="sd">        key is removed from the dict, so additional values are discarded:</span>

<span class="sd">        &gt;&gt;&gt; d = MultiDict({&quot;foo&quot;: [1, 2, 3]})</span>
<span class="sd">        &gt;&gt;&gt; d.pop(&quot;foo&quot;)</span>
<span class="sd">        1</span>
<span class="sd">        &gt;&gt;&gt; &quot;foo&quot; in d</span>
<span class="sd">        False</span>

<span class="sd">        :param key: the key to pop.</span>
<span class="sd">        :param default: if provided the value to return if the key was</span>
<span class="sd">                        not in the dictionary.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="k">return</span> <span class="nb">dict</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span>
        <span class="k">except</span> <span class="ne">KeyError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">default</span> <span class="ow">is</span> <span class="ow">not</span> <span class="n">_missing</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">default</span>
            <span class="k">raise</span> <span class="n">exceptions</span><span class="o">.</span><span class="n">BadRequestKeyError</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">e</span><span class="p">))</span>

    <span class="k">def</span> <span class="nf">popitem</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Pop an item from the dict.&quot;&quot;&quot;</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">item</span> <span class="o">=</span> <span class="nb">dict</span><span class="o">.</span><span class="n">popitem</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
            <span class="k">return</span> <span class="p">(</span><span class="n">item</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">item</span><span class="p">[</span><span class="mi">1</span><span class="p">][</span><span class="mi">0</span><span class="p">])</span>
        <span class="k">except</span> <span class="ne">KeyError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
            <span class="k">raise</span> <span class="n">exceptions</span><span class="o">.</span><span class="n">BadRequestKeyError</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">e</span><span class="p">))</span>

    <span class="k">def</span> <span class="nf">poplist</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Pop the list for a key from the dict.  If the key is not in the dict</span>
<span class="sd">        an empty list is returned.</span>

<span class="sd">        .. versionchanged:: 0.5</span>
<span class="sd">           If the key does no longer exist a list is returned instead of</span>
<span class="sd">           raising an error.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="nb">dict</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="p">[])</span>

    <span class="k">def</span> <span class="nf">popitemlist</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Pop a ``(key, list)`` tuple from the dict.&quot;&quot;&quot;</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="k">return</span> <span class="nb">dict</span><span class="o">.</span><span class="n">popitem</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">KeyError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
            <span class="k">raise</span> <span class="n">exceptions</span><span class="o">.</span><span class="n">BadRequestKeyError</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">e</span><span class="p">))</span>

    <span class="k">def</span> <span class="nf">__copy__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">__deepcopy__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">memo</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">deepcopy</span><span class="p">(</span><span class="n">memo</span><span class="o">=</span><span class="n">memo</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1">(</span><span class="si">%r</span><span class="s1">)&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="nb">list</span><span class="p">(</span><span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">multi</span><span class="o">=</span><span class="kc">True</span><span class="p">)))</span>


<span class="k">class</span> <span class="nc">_omd_bucket</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Wraps values in the :class:`OrderedMultiDict`.  This makes it</span>
<span class="sd">    possible to keep an order over multiple different keys.  It requires</span>
<span class="sd">    a lot of extra memory and slows down access a lot, but makes it</span>
<span class="sd">    possible to access elements in O(1) and iterate in O(n).</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="n">__slots__</span> <span class="o">=</span> <span class="p">(</span><span class="s1">&#39;prev&#39;</span><span class="p">,</span> <span class="s1">&#39;key&#39;</span><span class="p">,</span> <span class="s1">&#39;value&#39;</span><span class="p">,</span> <span class="s1">&#39;next&#39;</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">omd</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="bp">self</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="n">omd</span><span class="o">.</span><span class="n">_last_bucket</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">key</span> <span class="o">=</span> <span class="n">key</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="n">value</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="kc">None</span>

        <span class="k">if</span> <span class="n">omd</span><span class="o">.</span><span class="n">_first_bucket</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="n">omd</span><span class="o">.</span><span class="n">_first_bucket</span> <span class="o">=</span> <span class="bp">self</span>
        <span class="k">if</span> <span class="n">omd</span><span class="o">.</span><span class="n">_last_bucket</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="n">omd</span><span class="o">.</span><span class="n">_last_bucket</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="bp">self</span>
        <span class="n">omd</span><span class="o">.</span><span class="n">_last_bucket</span> <span class="o">=</span> <span class="bp">self</span>

    <span class="k">def</span> <span class="nf">unlink</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">omd</span><span class="p">):</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">prev</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">prev</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">next</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">next</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">next</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">prev</span>
        <span class="k">if</span> <span class="n">omd</span><span class="o">.</span><span class="n">_first_bucket</span> <span class="ow">is</span> <span class="bp">self</span><span class="p">:</span>
            <span class="n">omd</span><span class="o">.</span><span class="n">_first_bucket</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">next</span>
        <span class="k">if</span> <span class="n">omd</span><span class="o">.</span><span class="n">_last_bucket</span> <span class="ow">is</span> <span class="bp">self</span><span class="p">:</span>
            <span class="n">omd</span><span class="o">.</span><span class="n">_last_bucket</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">prev</span>


<span class="nd">@native_itermethods</span><span class="p">([</span><span class="s1">&#39;keys&#39;</span><span class="p">,</span> <span class="s1">&#39;values&#39;</span><span class="p">,</span> <span class="s1">&#39;items&#39;</span><span class="p">,</span> <span class="s1">&#39;lists&#39;</span><span class="p">,</span> <span class="s1">&#39;listvalues&#39;</span><span class="p">])</span>
<span class="k">class</span> <span class="nc">OrderedMultiDict</span><span class="p">(</span><span class="n">MultiDict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Works like a regular :class:`MultiDict` but preserves the</span>
<span class="sd">    order of the fields.  To convert the ordered multi dict into a</span>
<span class="sd">    list you can use the :meth:`items` method and pass it ``multi=True``.</span>

<span class="sd">    In general an :class:`OrderedMultiDict` is an order of magnitude</span>
<span class="sd">    slower than a :class:`MultiDict`.</span>

<span class="sd">    .. admonition:: note</span>

<span class="sd">       Due to a limitation in Python you cannot convert an ordered</span>
<span class="sd">       multi dict into a regular dict by using ``dict(multidict)``.</span>
<span class="sd">       Instead you have to use the :meth:`to_dict` method, otherwise</span>
<span class="sd">       the internal bucket objects are exposed.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">mapping</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_first_bucket</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_last_bucket</span> <span class="o">=</span> <span class="kc">None</span>
        <span class="k">if</span> <span class="n">mapping</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="n">OrderedMultiDict</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">mapping</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">MultiDict</span><span class="p">):</span>
            <span class="k">return</span> <span class="bp">NotImplemented</span>
        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">OrderedMultiDict</span><span class="p">):</span>
            <span class="n">iter1</span> <span class="o">=</span> <span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">multi</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
            <span class="n">iter2</span> <span class="o">=</span> <span class="n">iteritems</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">multi</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
            <span class="k">try</span><span class="p">:</span>
                <span class="k">for</span> <span class="n">k1</span><span class="p">,</span> <span class="n">v1</span> <span class="ow">in</span> <span class="n">iter1</span><span class="p">:</span>
                    <span class="n">k2</span><span class="p">,</span> <span class="n">v2</span> <span class="o">=</span> <span class="nb">next</span><span class="p">(</span><span class="n">iter2</span><span class="p">)</span>
                    <span class="k">if</span> <span class="n">k1</span> <span class="o">!=</span> <span class="n">k2</span> <span class="ow">or</span> <span class="n">v1</span> <span class="o">!=</span> <span class="n">v2</span><span class="p">:</span>
                        <span class="k">return</span> <span class="kc">False</span>
            <span class="k">except</span> <span class="ne">StopIteration</span><span class="p">:</span>
                <span class="k">return</span> <span class="kc">False</span>
            <span class="k">try</span><span class="p">:</span>
                <span class="nb">next</span><span class="p">(</span><span class="n">iter2</span><span class="p">)</span>
            <span class="k">except</span> <span class="ne">StopIteration</span><span class="p">:</span>
                <span class="k">return</span> <span class="kc">True</span>
            <span class="k">return</span> <span class="kc">False</span>
        <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">!=</span> <span class="nb">len</span><span class="p">(</span><span class="n">other</span><span class="p">):</span>
            <span class="k">return</span> <span class="kc">False</span>
        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">values</span> <span class="ow">in</span> <span class="n">iterlists</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
            <span class="k">if</span> <span class="n">other</span><span class="o">.</span><span class="n">getlist</span><span class="p">(</span><span class="n">key</span><span class="p">)</span> <span class="o">!=</span> <span class="n">values</span><span class="p">:</span>
                <span class="k">return</span> <span class="kc">False</span>
        <span class="k">return</span> <span class="kc">True</span>

    <span class="k">def</span> <span class="nf">__ne__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
        <span class="k">return</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">__eq__</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__reduce_ex__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">protocol</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="p">),</span> <span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">multi</span><span class="o">=</span><span class="kc">True</span><span class="p">)),)</span>

    <span class="k">def</span> <span class="nf">__getstate__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">list</span><span class="p">(</span><span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">multi</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span>

    <span class="k">def</span> <span class="nf">__setstate__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span><span class="p">):</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">values</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">add</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">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="k">return</span> <span class="nb">dict</span><span class="o">.</span><span class="n">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">value</span>
        <span class="k">raise</span> <span class="n">exceptions</span><span class="o">.</span><span class="n">BadRequestKeyError</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</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="bp">self</span><span class="o">.</span><span class="n">poplist</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">add</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">def</span> <span class="nf">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">keys</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="p">(</span><span class="n">key</span> <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">))</span>

    <span class="n">__iter__</span> <span class="o">=</span> <span class="n">keys</span>

    <span class="k">def</span> <span class="nf">values</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="p">(</span><span class="n">value</span> <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">))</span>

    <span class="k">def</span> <span class="nf">items</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">multi</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="n">ptr</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_first_bucket</span>
        <span class="k">if</span> <span class="n">multi</span><span class="p">:</span>
            <span class="k">while</span> <span class="n">ptr</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
                <span class="k">yield</span> <span class="n">ptr</span><span class="o">.</span><span class="n">key</span><span class="p">,</span> <span class="n">ptr</span><span class="o">.</span><span class="n">value</span>
                <span class="n">ptr</span> <span class="o">=</span> <span class="n">ptr</span><span class="o">.</span><span class="n">next</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="n">returned_keys</span> <span class="o">=</span> <span class="nb">set</span><span class="p">()</span>
            <span class="k">while</span> <span class="n">ptr</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
                <span class="k">if</span> <span class="n">ptr</span><span class="o">.</span><span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">returned_keys</span><span class="p">:</span>
                    <span class="n">returned_keys</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">ptr</span><span class="o">.</span><span class="n">key</span><span class="p">)</span>
                    <span class="k">yield</span> <span class="n">ptr</span><span class="o">.</span><span class="n">key</span><span class="p">,</span> <span class="n">ptr</span><span class="o">.</span><span class="n">value</span>
                <span class="n">ptr</span> <span class="o">=</span> <span class="n">ptr</span><span class="o">.</span><span class="n">next</span>

    <span class="k">def</span> <span class="nf">lists</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="n">returned_keys</span> <span class="o">=</span> <span class="nb">set</span><span class="p">()</span>
        <span class="n">ptr</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_first_bucket</span>
        <span class="k">while</span> <span class="n">ptr</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">ptr</span><span class="o">.</span><span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">returned_keys</span><span class="p">:</span>
                <span class="k">yield</span> <span class="n">ptr</span><span class="o">.</span><span class="n">key</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">getlist</span><span class="p">(</span><span class="n">ptr</span><span class="o">.</span><span class="n">key</span><span class="p">)</span>
                <span class="n">returned_keys</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">ptr</span><span class="o">.</span><span class="n">key</span><span class="p">)</span>
            <span class="n">ptr</span> <span class="o">=</span> <span class="n">ptr</span><span class="o">.</span><span class="n">next</span>

    <span class="k">def</span> <span class="nf">listvalues</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">values</span> <span class="ow">in</span> <span class="n">iterlists</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
            <span class="k">yield</span> <span class="n">values</span>

    <span class="k">def</span> <span class="nf">add</span><span class="p">(</span><span class="bp">self</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="nb">dict</span><span class="o">.</span><span class="n">setdefault</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="p">[])</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">_omd_bucket</span><span class="p">(</span><span class="bp">self</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">def</span> <span class="nf">getlist</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="nb">type</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">rv</span> <span class="o">=</span> <span class="nb">dict</span><span class="o">.</span><span class="n">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
            <span class="k">return</span> <span class="p">[]</span>
        <span class="k">if</span> <span class="nb">type</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">return</span> <span class="p">[</span><span class="n">x</span><span class="o">.</span><span class="n">value</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">rv</span><span class="p">]</span>
        <span class="n">result</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">rv</span><span class="p">:</span>
            <span class="k">try</span><span class="p">:</span>
                <span class="n">result</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">item</span><span class="o">.</span><span class="n">value</span><span class="p">))</span>
            <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
                <span class="k">pass</span>
        <span class="k">return</span> <span class="n">result</span>

    <span class="k">def</span> <span class="nf">setlist</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">new_list</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">poplist</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
        <span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">new_list</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">add</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">def</span> <span class="nf">setlistdefault</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default_list</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">&#39;setlistdefault is unsupported for &#39;</span>
                        <span class="s1">&#39;ordered multi dicts&#39;</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">mapping</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iter_multi_items</span><span class="p">(</span><span class="n">mapping</span><span class="p">):</span>
            <span class="n">OrderedMultiDict</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="bp">self</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">def</span> <span class="nf">poplist</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="n">buckets</span> <span class="o">=</span> <span class="nb">dict</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="p">())</span>
        <span class="k">for</span> <span class="n">bucket</span> <span class="ow">in</span> <span class="n">buckets</span><span class="p">:</span>
            <span class="n">bucket</span><span class="o">.</span><span class="n">unlink</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="k">return</span> <span class="p">[</span><span class="n">x</span><span class="o">.</span><span class="n">value</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">buckets</span><span class="p">]</span>

    <span class="k">def</span> <span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="n">_missing</span><span class="p">):</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">buckets</span> <span class="o">=</span> <span class="nb">dict</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">KeyError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">default</span> <span class="ow">is</span> <span class="ow">not</span> <span class="n">_missing</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">default</span>
            <span class="k">raise</span> <span class="n">exceptions</span><span class="o">.</span><span class="n">BadRequestKeyError</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">e</span><span class="p">))</span>
        <span class="k">for</span> <span class="n">bucket</span> <span class="ow">in</span> <span class="n">buckets</span><span class="p">:</span>
            <span class="n">bucket</span><span class="o">.</span><span class="n">unlink</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">buckets</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">value</span>

    <span class="k">def</span> <span class="nf">popitem</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">key</span><span class="p">,</span> <span class="n">buckets</span> <span class="o">=</span> <span class="nb">dict</span><span class="o">.</span><span class="n">popitem</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">KeyError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
            <span class="k">raise</span> <span class="n">exceptions</span><span class="o">.</span><span class="n">BadRequestKeyError</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">e</span><span class="p">))</span>
        <span class="k">for</span> <span class="n">bucket</span> <span class="ow">in</span> <span class="n">buckets</span><span class="p">:</span>
            <span class="n">bucket</span><span class="o">.</span><span class="n">unlink</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">key</span><span class="p">,</span> <span class="n">buckets</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">value</span>

    <span class="k">def</span> <span class="nf">popitemlist</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">key</span><span class="p">,</span> <span class="n">buckets</span> <span class="o">=</span> <span class="nb">dict</span><span class="o">.</span><span class="n">popitem</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">KeyError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
            <span class="k">raise</span> <span class="n">exceptions</span><span class="o">.</span><span class="n">BadRequestKeyError</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">e</span><span class="p">))</span>
        <span class="k">for</span> <span class="n">bucket</span> <span class="ow">in</span> <span class="n">buckets</span><span class="p">:</span>
            <span class="n">bucket</span><span class="o">.</span><span class="n">unlink</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">key</span><span class="p">,</span> <span class="p">[</span><span class="n">x</span><span class="o">.</span><span class="n">value</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">buckets</span><span class="p">]</span>


<span class="k">def</span> <span class="nf">_options_header_vkw</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">kw</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">dump_options_header</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="nb">dict</span><span class="p">((</span><span class="n">k</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">&#39;_&#39;</span><span class="p">,</span> <span class="s1">&#39;-&#39;</span><span class="p">),</span> <span class="n">v</span><span class="p">)</span>
                                           <span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">kw</span><span class="o">.</span><span class="n">items</span><span class="p">()))</span>


<span class="k">def</span> <span class="nf">_unicodify_header_value</span><span class="p">(</span><span class="n">value</span><span class="p">):</span>
    <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
        <span class="n">value</span> <span class="o">=</span> <span class="n">value</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="s1">&#39;latin-1&#39;</span><span class="p">)</span>
    <span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">text_type</span><span class="p">):</span>
        <span class="n">value</span> <span class="o">=</span> <span class="n">text_type</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">value</span>


<span class="nd">@native_itermethods</span><span class="p">([</span><span class="s1">&#39;keys&#39;</span><span class="p">,</span> <span class="s1">&#39;values&#39;</span><span class="p">,</span> <span class="s1">&#39;items&#39;</span><span class="p">])</span>
<span class="k">class</span> <span class="nc">Headers</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;An object that stores some headers.  It has a dict-like interface</span>
<span class="sd">    but is ordered and can store the same keys multiple times.</span>

<span class="sd">    This data structure is useful if you want a nicer way to handle WSGI</span>
<span class="sd">    headers which are stored as tuples in a list.</span>

<span class="sd">    From Werkzeug 0.3 onwards, the :exc:`KeyError` raised by this class is</span>
<span class="sd">    also a subclass of the :class:`~exceptions.BadRequest` HTTP exception</span>
<span class="sd">    and will render a page for a ``400 BAD REQUEST`` if caught in a</span>
<span class="sd">    catch-all for HTTP exceptions.</span>

<span class="sd">    Headers is mostly compatible with the Python :class:`wsgiref.headers.Headers`</span>
<span class="sd">    class, with the exception of `__getitem__`.  :mod:`wsgiref` will return</span>
<span class="sd">    `None` for ``headers[&#39;missing&#39;]``, whereas :class:`Headers` will raise</span>
<span class="sd">    a :class:`KeyError`.</span>

<span class="sd">    To create a new :class:`Headers` object pass it a list or dict of headers</span>
<span class="sd">    which are used as default values.  This does not reuse the list passed</span>
<span class="sd">    to the constructor for internal usage.</span>

<span class="sd">    :param defaults: The list of default values for the :class:`Headers`.</span>

<span class="sd">    .. versionchanged:: 0.9</span>
<span class="sd">       This data structure now stores unicode values similar to how the</span>
<span class="sd">       multi dicts do it.  The main difference is that bytes can be set as</span>
<span class="sd">       well which will automatically be latin1 decoded.</span>

<span class="sd">    .. versionchanged:: 0.9</span>
<span class="sd">       The :meth:`linked` function was removed without replacement as it</span>
<span class="sd">       was an API that does not support the changes to the encoding model.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">defaults</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_list</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="k">if</span> <span class="n">defaults</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">defaults</span><span class="p">,</span> <span class="p">(</span><span class="nb">list</span><span class="p">,</span> <span class="n">Headers</span><span class="p">)):</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">defaults</span><span class="p">)</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">defaults</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">_get_mode</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="n">_get_mode</span><span class="p">:</span>
            <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">integer_types</span><span class="p">):</span>
                <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
            <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="nb">slice</span><span class="p">):</span>
                <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">[</span><span class="n">key</span><span class="p">])</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">string_types</span><span class="p">):</span>
            <span class="k">raise</span> <span class="n">exceptions</span><span class="o">.</span><span class="n">BadRequestKeyError</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
        <span class="n">ikey</span> <span class="o">=</span> <span class="n">key</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
        <span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">k</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span> <span class="o">==</span> <span class="n">ikey</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">v</span>
        <span class="c1"># micro optimization: if we are in get mode we will catch that</span>
        <span class="c1"># exception one stack level down so we can raise a standard</span>
        <span class="c1"># key error instead of our special one.</span>
        <span class="k">if</span> <span class="n">_get_mode</span><span class="p">:</span>
            <span class="k">raise</span> <span class="ne">KeyError</span><span class="p">()</span>
        <span class="k">raise</span> <span class="n">exceptions</span><span class="o">.</span><span class="n">BadRequestKeyError</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
        <span class="k">return</span> <span class="n">other</span><span class="o">.</span><span class="n">__class__</span> <span class="ow">is</span> <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span> <span class="ow">and</span> \
            <span class="nb">set</span><span class="p">(</span><span class="n">other</span><span class="o">.</span><span class="n">_list</span><span class="p">)</span> <span class="o">==</span> <span class="nb">set</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__ne__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
        <span class="k">return</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">__eq__</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">get</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="nb">type</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">as_bytes</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return the default value if the requested data doesn&#39;t exist.</span>
<span class="sd">        If `type` is provided and is a callable it should convert the value,</span>
<span class="sd">        return it or raise a :exc:`ValueError` if that is not possible.  In</span>
<span class="sd">        this case the function will return the default as if the value was not</span>
<span class="sd">        found:</span>

<span class="sd">        &gt;&gt;&gt; d = Headers([(&#39;Content-Length&#39;, &#39;42&#39;)])</span>
<span class="sd">        &gt;&gt;&gt; d.get(&#39;Content-Length&#39;, type=int)</span>
<span class="sd">        42</span>

<span class="sd">        If a headers object is bound you must not add unicode strings</span>
<span class="sd">        because no encoding takes place.</span>

<span class="sd">        .. versionadded:: 0.9</span>
<span class="sd">           Added support for `as_bytes`.</span>

<span class="sd">        :param key: The key to be looked up.</span>
<span class="sd">        :param default: The default value to be returned if the key can&#39;t</span>
<span class="sd">                        be looked up.  If not further specified `None` is</span>
<span class="sd">                        returned.</span>
<span class="sd">        :param type: A callable that is used to cast the value in the</span>
<span class="sd">                     :class:`Headers`.  If a :exc:`ValueError` is raised</span>
<span class="sd">                     by this callable the default value is returned.</span>
<span class="sd">        :param as_bytes: return bytes instead of unicode strings.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">rv</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__getitem__</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">_get_mode</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">default</span>
        <span class="k">if</span> <span class="n">as_bytes</span><span class="p">:</span>
            <span class="n">rv</span> <span class="o">=</span> <span class="n">rv</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="s1">&#39;latin1&#39;</span><span class="p">)</span>
        <span class="k">if</span> <span class="nb">type</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">rv</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="k">return</span> <span class="nb">type</span><span class="p">(</span><span class="n">rv</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">default</span>

    <span class="k">def</span> <span class="nf">getlist</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="nb">type</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">as_bytes</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return the list of items for a given key. If that key is not in the</span>
<span class="sd">        :class:`Headers`, the return value will be an empty list.  Just as</span>
<span class="sd">        :meth:`get` :meth:`getlist` accepts a `type` parameter.  All items will</span>
<span class="sd">        be converted with the callable defined there.</span>

<span class="sd">        .. versionadded:: 0.9</span>
<span class="sd">           Added support for `as_bytes`.</span>

<span class="sd">        :param key: The key to be looked up.</span>
<span class="sd">        :param type: A callable that is used to cast the value in the</span>
<span class="sd">                     :class:`Headers`.  If a :exc:`ValueError` is raised</span>
<span class="sd">                     by this callable the value will be removed from the list.</span>
<span class="sd">        :return: a :class:`list` of all the values for the key.</span>
<span class="sd">        :param as_bytes: return bytes instead of unicode strings.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="n">ikey</span> <span class="o">=</span> <span class="n">key</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
        <span class="n">result</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">k</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span> <span class="o">==</span> <span class="n">ikey</span><span class="p">:</span>
                <span class="k">if</span> <span class="n">as_bytes</span><span class="p">:</span>
                    <span class="n">v</span> <span class="o">=</span> <span class="n">v</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="s1">&#39;latin1&#39;</span><span class="p">)</span>
                <span class="k">if</span> <span class="nb">type</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
                    <span class="k">try</span><span class="p">:</span>
                        <span class="n">v</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
                    <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
                        <span class="k">continue</span>
                <span class="n">result</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">result</span>

    <span class="k">def</span> <span class="nf">get_all</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return a list of all the values for the named field.</span>

<span class="sd">        This method is compatible with the :mod:`wsgiref`</span>
<span class="sd">        :meth:`~wsgiref.headers.Headers.get_all` method.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">getlist</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">items</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">lower</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">lower</span><span class="p">:</span>
                <span class="n">key</span> <span class="o">=</span> <span class="n">key</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
            <span class="k">yield</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span>

    <span class="k">def</span> <span class="nf">keys</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">lower</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">_</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">lower</span><span class="p">):</span>
            <span class="k">yield</span> <span class="n">key</span>

    <span class="k">def</span> <span class="nf">values</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">_</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
            <span class="k">yield</span> <span class="n">value</span>

    <span class="k">def</span> <span class="nf">extend</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">iterable</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Extend the headers with a dict or an iterable yielding keys and</span>
<span class="sd">        values.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">iterable</span><span class="p">,</span> <span class="nb">dict</span><span class="p">):</span>
            <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="n">iterable</span><span class="p">):</span>
                <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="p">(</span><span class="nb">tuple</span><span class="p">,</span> <span class="nb">list</span><span class="p">)):</span>
                    <span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">value</span><span class="p">:</span>
                        <span class="bp">self</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">v</span><span class="p">)</span>
                <span class="k">else</span><span class="p">:</span>
                    <span class="bp">self</span><span class="o">.</span><span class="n">add</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">else</span><span class="p">:</span>
            <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iterable</span><span class="p">:</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">add</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">def</span> <span class="nf">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">_index_operation</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
        <span class="k">if</span> <span class="n">_index_operation</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="p">(</span><span class="n">integer_types</span><span class="p">,</span> <span class="nb">slice</span><span class="p">)):</span>
            <span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
            <span class="k">return</span>
        <span class="n">key</span> <span class="o">=</span> <span class="n">key</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
        <span class="n">new</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">k</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span> <span class="o">!=</span> <span class="n">key</span><span class="p">:</span>
                <span class="n">new</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">k</span><span class="p">,</span> <span class="n">v</span><span class="p">))</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">new</span>

    <span class="k">def</span> <span class="nf">remove</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Remove a key.</span>

<span class="sd">        :param key: The key to be removed.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">__delitem__</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">_index_operation</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="n">_missing</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Removes and returns a key or index.</span>

<span class="sd">        :param key: The key to be popped.  If this is an integer the item at</span>
<span class="sd">                    that position is removed, if it&#39;s a string the value for</span>
<span class="sd">                    that key is.  If the key is omitted or `None` the last</span>
<span class="sd">                    item is removed.</span>
<span class="sd">        :return: an item.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="n">key</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">integer_types</span><span class="p">):</span>
            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">rv</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">default</span> <span class="ow">is</span> <span class="ow">not</span> <span class="n">_missing</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">default</span>
            <span class="k">raise</span>
        <span class="k">return</span> <span class="n">rv</span>

    <span class="k">def</span> <span class="nf">popitem</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Removes a key or index and returns a (key, value) item.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Check if a key is present.&quot;&quot;&quot;</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">__getitem__</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">_get_mode</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
            <span class="k">return</span> <span class="kc">False</span>
        <span class="k">return</span> <span class="kc">True</span>

    <span class="n">has_key</span> <span class="o">=</span> <span class="n">__contains__</span>

    <span class="k">def</span> <span class="nf">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Yield ``(key, value)`` tuples.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="nb">iter</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__len__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">add</span><span class="p">(</span><span class="bp">self</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="o">**</span><span class="n">kw</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Add a new header tuple to the list.</span>

<span class="sd">        Keyword arguments can specify additional parameters for the header</span>
<span class="sd">        value, with underscores converted to dashes::</span>

<span class="sd">        &gt;&gt;&gt; d = Headers()</span>
<span class="sd">        &gt;&gt;&gt; d.add(&#39;Content-Type&#39;, &#39;text/plain&#39;)</span>
<span class="sd">        &gt;&gt;&gt; d.add(&#39;Content-Disposition&#39;, &#39;attachment&#39;, filename=&#39;foo.png&#39;)</span>

<span class="sd">        The keyword argument dumping uses :func:`dump_options_header`</span>
<span class="sd">        behind the scenes.</span>

<span class="sd">        .. versionadded:: 0.4.1</span>
<span class="sd">            keyword arguments were added for :mod:`wsgiref` compatibility.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="n">kw</span><span class="p">:</span>
            <span class="n">_value</span> <span class="o">=</span> <span class="n">_options_header_vkw</span><span class="p">(</span><span class="n">_value</span><span class="p">,</span> <span class="n">kw</span><span class="p">)</span>
        <span class="n">_value</span> <span class="o">=</span> <span class="n">_unicodify_header_value</span><span class="p">(</span><span class="n">_value</span><span class="p">)</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_validate_value</span><span class="p">(</span><span class="n">_value</span><span class="p">)</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="o">.</span><span class="n">append</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">def</span> <span class="nf">_validate_value</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">text_type</span><span class="p">):</span>
            <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">&#39;Value should be unicode.&#39;</span><span class="p">)</span>
        <span class="k">if</span> <span class="s1">u&#39;</span><span class="se">\n</span><span class="s1">&#39;</span> <span class="ow">in</span> <span class="n">value</span> <span class="ow">or</span> <span class="s1">u&#39;</span><span class="se">\r</span><span class="s1">&#39;</span> <span class="ow">in</span> <span class="n">value</span><span class="p">:</span>
            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">&#39;Detected newline in header value.  This is &#39;</span>
                             <span class="s1">&#39;a potential security problem&#39;</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">add_header</span><span class="p">(</span><span class="bp">self</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="o">**</span><span class="n">_kw</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Add a new header tuple to the list.</span>

<span class="sd">        An alias for :meth:`add` for compatibility with the :mod:`wsgiref`</span>
<span class="sd">        :meth:`~wsgiref.headers.Headers.add_header` method.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">add</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="o">**</span><span class="n">_kw</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Clears all headers.&quot;&quot;&quot;</span>
        <span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">[:]</span>

    <span class="k">def</span> <span class="nf">set</span><span class="p">(</span><span class="bp">self</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="o">**</span><span class="n">kw</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Remove all header tuples for `key` and add a new one.  The newly</span>
<span class="sd">        added key either appears at the end of the list if there was no</span>
<span class="sd">        entry or replaces the first one.</span>

<span class="sd">        Keyword arguments can specify additional parameters for the header</span>
<span class="sd">        value, with underscores converted to dashes.  See :meth:`add` for</span>
<span class="sd">        more information.</span>

<span class="sd">        .. versionchanged:: 0.6.1</span>
<span class="sd">           :meth:`set` now accepts the same arguments as :meth:`add`.</span>

<span class="sd">        :param key: The key to be inserted.</span>
<span class="sd">        :param value: The value to be inserted.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="n">kw</span><span class="p">:</span>
            <span class="n">_value</span> <span class="o">=</span> <span class="n">_options_header_vkw</span><span class="p">(</span><span class="n">_value</span><span class="p">,</span> <span class="n">kw</span><span class="p">)</span>
        <span class="n">_value</span> <span class="o">=</span> <span class="n">_unicodify_header_value</span><span class="p">(</span><span class="n">_value</span><span class="p">)</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_validate_value</span><span class="p">(</span><span class="n">_value</span><span class="p">)</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="o">.</span><span class="n">append</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">return</span>
        <span class="n">listiter</span> <span class="o">=</span> <span class="nb">iter</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">)</span>
        <span class="n">ikey</span> <span class="o">=</span> <span class="n">_key</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
        <span class="k">for</span> <span class="n">idx</span><span class="p">,</span> <span class="p">(</span><span class="n">old_key</span><span class="p">,</span> <span class="n">old_value</span><span class="p">)</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">listiter</span><span class="p">):</span>
            <span class="k">if</span> <span class="n">old_key</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span> <span class="o">==</span> <span class="n">ikey</span><span class="p">:</span>
                <span class="c1"># replace first ocurrence</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">[</span><span class="n">idx</span><span class="p">]</span> <span class="o">=</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">break</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="o">.</span><span class="n">append</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">return</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">[</span><span class="n">idx</span> <span class="o">+</span> <span class="mi">1</span><span class="p">:]</span> <span class="o">=</span> <span class="p">[</span><span class="n">t</span> <span class="k">for</span> <span class="n">t</span> <span class="ow">in</span> <span class="n">listiter</span> <span class="k">if</span> <span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span> <span class="o">!=</span> <span class="n">ikey</span><span class="p">]</span>

    <span class="k">def</span> <span class="nf">setdefault</span><span class="p">(</span><span class="bp">self</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="sd">&quot;&quot;&quot;Returns the value for the key if it is in the dict, otherwise it</span>
<span class="sd">        returns `default` and sets that value for `key`.</span>

<span class="sd">        :param key: The key to be looked up.</span>
<span class="sd">        :param default: The default value to be returned if the key is not</span>
<span class="sd">                        in the dict.  If not further specified it&#39;s `None`.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">set</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">return</span> <span class="n">value</span>

    <span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</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="sd">&quot;&quot;&quot;Like :meth:`set` but also supports index/slice based setting.&quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="p">(</span><span class="nb">slice</span><span class="p">,</span> <span class="n">integer_types</span><span class="p">)):</span>
            <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">integer_types</span><span class="p">):</span>
                <span class="n">value</span> <span class="o">=</span> <span class="p">[</span><span class="n">value</span><span class="p">]</span>
            <span class="n">value</span> <span class="o">=</span> <span class="p">[(</span><span class="n">k</span><span class="p">,</span> <span class="n">_unicodify_header_value</span><span class="p">(</span><span class="n">v</span><span class="p">))</span> <span class="k">for</span> <span class="p">(</span><span class="n">k</span><span class="p">,</span> <span class="n">v</span><span class="p">)</span> <span class="ow">in</span> <span class="n">value</span><span class="p">]</span>
            <span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">_validate_value</span><span class="p">(</span><span class="n">v</span><span class="p">)</span> <span class="k">for</span> <span class="p">(</span><span class="n">k</span><span class="p">,</span> <span class="n">v</span><span class="p">)</span> <span class="ow">in</span> <span class="n">value</span><span class="p">]</span>
            <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">integer_types</span><span class="p">):</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">set</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">def</span> <span class="nf">to_list</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">charset</span><span class="o">=</span><span class="s1">&#39;iso-8859-1&#39;</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Convert the headers into a list suitable for WSGI.&quot;&quot;&quot;</span>
        <span class="kn">from</span> <span class="nn">warnings</span> <span class="k">import</span> <span class="n">warn</span>
        <span class="n">warn</span><span class="p">(</span><span class="ne">DeprecationWarning</span><span class="p">(</span><span class="s1">&#39;Method removed, use to_wsgi_list instead&#39;</span><span class="p">),</span>
             <span class="n">stacklevel</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">to_wsgi_list</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">to_wsgi_list</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Convert the headers into a list suitable for WSGI.</span>

<span class="sd">        The values are byte strings in Python 2 converted to latin1 and unicode</span>
<span class="sd">        strings in Python 3 for the WSGI server to encode.</span>

<span class="sd">        :return: list</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="n">PY2</span><span class="p">:</span>
            <span class="k">return</span> <span class="p">[(</span><span class="n">to_native</span><span class="p">(</span><span class="n">k</span><span class="p">),</span> <span class="n">v</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="s1">&#39;latin1&#39;</span><span class="p">))</span> <span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">]</span>
        <span class="k">return</span> <span class="nb">list</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_list</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__copy__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Returns formatted headers suitable for HTTP transmission.&quot;&quot;&quot;</span>
        <span class="n">strs</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">to_wsgi_list</span><span class="p">():</span>
            <span class="n">strs</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="s1">&#39;</span><span class="si">%s</span><span class="s1">: </span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</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="n">strs</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="s1">&#39;</span><span class="se">\r\n</span><span class="s1">&#39;</span><span class="p">)</span>
        <span class="k">return</span> <span class="s1">&#39;</span><span class="se">\r\n</span><span class="s1">&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">strs</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1">(</span><span class="si">%r</span><span class="s1">)&#39;</span> <span class="o">%</span> <span class="p">(</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span>
            <span class="nb">list</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="p">)</span>


<span class="k">class</span> <span class="nc">ImmutableHeadersMixin</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Makes a :class:`Headers` immutable.  We do not mark them as</span>
<span class="sd">    hashable though since the only usecase for this datastructure</span>
<span class="sd">    in Werkzeug is a view on a mutable structure.</span>

<span class="sd">    .. versionadded:: 0.5</span>

<span class="sd">    :private:</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</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="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
    <span class="nb">set</span> <span class="o">=</span> <span class="n">__setitem__</span>

    <span class="k">def</span> <span class="nf">add</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
    <span class="n">remove</span> <span class="o">=</span> <span class="n">add_header</span> <span class="o">=</span> <span class="n">add</span>

    <span class="k">def</span> <span class="nf">extend</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">iterable</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">insert</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">pos</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">index</span><span class="o">=-</span><span class="mi">1</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">popitem</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">setdefault</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="p">):</span>
        <span class="n">is_immutable</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">EnvironHeaders</span><span class="p">(</span><span class="n">ImmutableHeadersMixin</span><span class="p">,</span> <span class="n">Headers</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Read only version of the headers from a WSGI environment.  This</span>
<span class="sd">    provides the same interface as `Headers` and is constructed from</span>
<span class="sd">    a WSGI environment.</span>

<span class="sd">    From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a</span>
<span class="sd">    subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will</span>
<span class="sd">    render a page for a ``400 BAD REQUEST`` if caught in a catch-all for</span>
<span class="sd">    HTTP exceptions.</span>
<span class="sd">    &quot;&quot;&quot;</span>

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

    <span class="k">def</span> <span class="nf">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">environ</span> <span class="ow">is</span> <span class="n">other</span><span class="o">.</span><span class="n">environ</span>

    <span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">_get_mode</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="c1"># _get_mode is a no-op for this class as there is no index but</span>
        <span class="c1"># used because get() calls it.</span>
        <span class="n">key</span> <span class="o">=</span> <span class="n">key</span><span class="o">.</span><span class="n">upper</span><span class="p">()</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">&#39;-&#39;</span><span class="p">,</span> <span class="s1">&#39;_&#39;</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">&#39;CONTENT_TYPE&#39;</span><span class="p">,</span> <span class="s1">&#39;CONTENT_LENGTH&#39;</span><span class="p">):</span>
            <span class="k">return</span> <span class="n">_unicodify_header_value</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="n">key</span><span class="p">])</span>
        <span class="k">return</span> <span class="n">_unicodify_header_value</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s1">&#39;HTTP_&#39;</span> <span class="o">+</span> <span class="n">key</span><span class="p">])</span>

    <span class="k">def</span> <span class="nf">__len__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="c1"># the iter is necessary because otherwise list calls our</span>
        <span class="c1"># len which would call list again and so forth.</span>
        <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="nb">iter</span><span class="p">(</span><span class="bp">self</span><span class="p">)))</span>

    <span class="k">def</span> <span class="nf">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">environ</span><span class="p">):</span>
            <span class="k">if</span> <span class="n">key</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s1">&#39;HTTP_&#39;</span><span class="p">)</span> <span class="ow">and</span> <span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> \
               <span class="p">(</span><span class="s1">&#39;HTTP_CONTENT_TYPE&#39;</span><span class="p">,</span> <span class="s1">&#39;HTTP_CONTENT_LENGTH&#39;</span><span class="p">):</span>
                <span class="k">yield</span> <span class="p">(</span><span class="n">key</span><span class="p">[</span><span class="mi">5</span><span class="p">:]</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">&#39;_&#39;</span><span class="p">,</span> <span class="s1">&#39;-&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">title</span><span class="p">(),</span>
                       <span class="n">_unicodify_header_value</span><span class="p">(</span><span class="n">value</span><span class="p">))</span>
            <span class="k">elif</span> <span class="n">key</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">&#39;CONTENT_TYPE&#39;</span><span class="p">,</span> <span class="s1">&#39;CONTENT_LENGTH&#39;</span><span class="p">):</span>
                <span class="k">yield</span> <span class="p">(</span><span class="n">key</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">&#39;_&#39;</span><span class="p">,</span> <span class="s1">&#39;-&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">title</span><span class="p">(),</span>
                       <span class="n">_unicodify_header_value</span><span class="p">(</span><span class="n">value</span><span class="p">))</span>

    <span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">&#39;cannot create </span><span class="si">%r</span><span class="s1"> copies&#39;</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">)</span>


<span class="nd">@native_itermethods</span><span class="p">([</span><span class="s1">&#39;keys&#39;</span><span class="p">,</span> <span class="s1">&#39;values&#39;</span><span class="p">,</span> <span class="s1">&#39;items&#39;</span><span class="p">,</span> <span class="s1">&#39;lists&#39;</span><span class="p">,</span> <span class="s1">&#39;listvalues&#39;</span><span class="p">])</span>
<span class="k">class</span> <span class="nc">CombinedMultiDict</span><span class="p">(</span><span class="n">ImmutableMultiDictMixin</span><span class="p">,</span> <span class="n">MultiDict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;A read only :class:`MultiDict` that you can pass multiple :class:`MultiDict`</span>
<span class="sd">    instances as sequence and it will combine the return values of all wrapped</span>
<span class="sd">    dicts:</span>

<span class="sd">    &gt;&gt;&gt; from werkzeug.datastructures import CombinedMultiDict, MultiDict</span>
<span class="sd">    &gt;&gt;&gt; post = MultiDict([(&#39;foo&#39;, &#39;bar&#39;)])</span>
<span class="sd">    &gt;&gt;&gt; get = MultiDict([(&#39;blub&#39;, &#39;blah&#39;)])</span>
<span class="sd">    &gt;&gt;&gt; combined = CombinedMultiDict([get, post])</span>
<span class="sd">    &gt;&gt;&gt; combined[&#39;foo&#39;]</span>
<span class="sd">    &#39;bar&#39;</span>
<span class="sd">    &gt;&gt;&gt; combined[&#39;blub&#39;]</span>
<span class="sd">    &#39;blah&#39;</span>

<span class="sd">    This works for all read operations and will raise a `TypeError` for</span>
<span class="sd">    methods that usually change data which isn&#39;t possible.</span>

<span class="sd">    From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a</span>
<span class="sd">    subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will</span>
<span class="sd">    render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP</span>
<span class="sd">    exceptions.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__reduce_ex__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">protocol</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="p">),</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">dicts</span><span class="p">,)</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">dicts</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">dicts</span> <span class="o">=</span> <span class="n">dicts</span> <span class="ow">or</span> <span class="p">[]</span>

    <span class="nd">@classmethod</span>
    <span class="k">def</span> <span class="nf">fromkeys</span><span class="p">(</span><span class="n">cls</span><span class="p">):</span>
        <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">&#39;cannot create </span><span class="si">%r</span><span class="s1"> instances by fromkeys&#39;</span> <span class="o">%</span>
                        <span class="n">cls</span><span class="o">.</span><span class="n">__name__</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">d</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">dicts</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">d</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">d</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
        <span class="k">raise</span> <span class="n">exceptions</span><span class="o">.</span><span class="n">BadRequestKeyError</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">get</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="nb">type</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">d</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">dicts</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">d</span><span class="p">:</span>
                <span class="k">if</span> <span class="nb">type</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
                    <span class="k">try</span><span class="p">:</span>
                        <span class="k">return</span> <span class="nb">type</span><span class="p">(</span><span class="n">d</span><span class="p">[</span><span class="n">key</span><span class="p">])</span>
                    <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
                        <span class="k">continue</span>
                <span class="k">return</span> <span class="n">d</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
        <span class="k">return</span> <span class="n">default</span>

    <span class="k">def</span> <span class="nf">getlist</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="nb">type</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="n">rv</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="k">for</span> <span class="n">d</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">dicts</span><span class="p">:</span>
            <span class="n">rv</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">d</span><span class="o">.</span><span class="n">getlist</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="nb">type</span><span class="p">))</span>
        <span class="k">return</span> <span class="n">rv</span>

    <span class="k">def</span> <span class="nf">_keys_impl</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;This function exists so __len__ can be implemented more efficiently,</span>
<span class="sd">        saving one list creation from an iterator.</span>

<span class="sd">        Using this for Python 2&#39;s ``dict.keys`` behavior would be useless since</span>
<span class="sd">        `dict.keys` in Python 2 returns a list, while we have a set here.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="n">rv</span> <span class="o">=</span> <span class="nb">set</span><span class="p">()</span>
        <span class="k">for</span> <span class="n">d</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">dicts</span><span class="p">:</span>
            <span class="n">rv</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">iterkeys</span><span class="p">(</span><span class="n">d</span><span class="p">))</span>
        <span class="k">return</span> <span class="n">rv</span>

    <span class="k">def</span> <span class="nf">keys</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">iter</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_keys_impl</span><span class="p">())</span>

    <span class="n">__iter__</span> <span class="o">=</span> <span class="n">keys</span>

    <span class="k">def</span> <span class="nf">items</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">multi</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="n">found</span> <span class="o">=</span> <span class="nb">set</span><span class="p">()</span>
        <span class="k">for</span> <span class="n">d</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">dicts</span><span class="p">:</span>
            <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="n">d</span><span class="p">,</span> <span class="n">multi</span><span class="p">):</span>
                <span class="k">if</span> <span class="n">multi</span><span class="p">:</span>
                    <span class="k">yield</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span>
                <span class="k">elif</span> <span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">found</span><span class="p">:</span>
                    <span class="n">found</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
                    <span class="k">yield</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span>

    <span class="k">def</span> <span class="nf">values</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
            <span class="k">yield</span> <span class="n">value</span>

    <span class="k">def</span> <span class="nf">lists</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="n">rv</span> <span class="o">=</span> <span class="p">{}</span>
        <span class="k">for</span> <span class="n">d</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">dicts</span><span class="p">:</span>
            <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">values</span> <span class="ow">in</span> <span class="n">iterlists</span><span class="p">(</span><span class="n">d</span><span class="p">):</span>
                <span class="n">rv</span><span class="o">.</span><span class="n">setdefault</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="p">[])</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">values</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">iteritems</span><span class="p">(</span><span class="n">rv</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">listvalues</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">lists</span><span class="p">())</span>

    <span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return a shallow copy of this object.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">dicts</span><span class="p">[:])</span>

    <span class="k">def</span> <span class="nf">to_dict</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">flat</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return the contents as regular dict.  If `flat` is `True` the</span>
<span class="sd">        returned dict will only have the first item present, if `flat` is</span>
<span class="sd">        `False` all values will be returned as lists.</span>

<span class="sd">        :param flat: If set to `False` the dict returned will have lists</span>
<span class="sd">                     with all the values in it.  Otherwise it will only</span>
<span class="sd">                     contain the first item for each key.</span>
<span class="sd">        :return: a :class:`dict`</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="n">rv</span> <span class="o">=</span> <span class="p">{}</span>
        <span class="k">for</span> <span class="n">d</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">dicts</span><span class="p">):</span>
            <span class="n">rv</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">d</span><span class="o">.</span><span class="n">to_dict</span><span class="p">(</span><span class="n">flat</span><span class="p">))</span>
        <span class="k">return</span> <span class="n">rv</span>

    <span class="k">def</span> <span class="nf">__len__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_keys_impl</span><span class="p">())</span>

    <span class="k">def</span> <span class="nf">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">d</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">dicts</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">d</span><span class="p">:</span>
                <span class="k">return</span> <span class="kc">True</span>
        <span class="k">return</span> <span class="kc">False</span>

    <span class="n">has_key</span> <span class="o">=</span> <span class="n">__contains__</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1">(</span><span class="si">%r</span><span class="s1">)&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">dicts</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">FileMultiDict</span><span class="p">(</span><span class="n">MultiDict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;A special :class:`MultiDict` that has convenience methods to add</span>
<span class="sd">    files to it.  This is used for :class:`EnvironBuilder` and generally</span>
<span class="sd">    useful for unittesting.</span>

<span class="sd">    .. versionadded:: 0.5</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">add_file</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">file</span><span class="p">,</span> <span class="n">filename</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">content_type</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Adds a new file to the dict.  `file` can be a file name or</span>
<span class="sd">        a :class:`file`-like or a :class:`FileStorage` object.</span>

<span class="sd">        :param name: the name of the field.</span>
<span class="sd">        :param file: a filename or :class:`file`-like object</span>
<span class="sd">        :param filename: an optional filename</span>
<span class="sd">        :param content_type: an optional content type</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">file</span><span class="p">,</span> <span class="n">FileStorage</span><span class="p">):</span>
            <span class="n">value</span> <span class="o">=</span> <span class="n">file</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">file</span><span class="p">,</span> <span class="n">string_types</span><span class="p">):</span>
                <span class="k">if</span> <span class="n">filename</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
                    <span class="n">filename</span> <span class="o">=</span> <span class="n">file</span>
                <span class="n">file</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="n">file</span><span class="p">,</span> <span class="s1">&#39;rb&#39;</span><span class="p">)</span>
            <span class="k">if</span> <span class="n">filename</span> <span class="ow">and</span> <span class="n">content_type</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
                <span class="n">content_type</span> <span class="o">=</span> <span class="n">mimetypes</span><span class="o">.</span><span class="n">guess_type</span><span class="p">(</span><span class="n">filename</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span> <span class="ow">or</span> \
                    <span class="s1">&#39;application/octet-stream&#39;</span>
            <span class="n">value</span> <span class="o">=</span> <span class="n">FileStorage</span><span class="p">(</span><span class="n">file</span><span class="p">,</span> <span class="n">filename</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">content_type</span><span class="p">)</span>

        <span class="bp">self</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">ImmutableDict</span><span class="p">(</span><span class="n">ImmutableDictMixin</span><span class="p">,</span> <span class="nb">dict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;An immutable :class:`dict`.</span>

<span class="sd">    .. versionadded:: 0.5</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1">(</span><span class="si">%s</span><span class="s1">)&#39;</span> <span class="o">%</span> <span class="p">(</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span>
            <span class="nb">dict</span><span class="o">.</span><span class="n">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">),</span>
        <span class="p">)</span>

    <span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return a shallow mutable copy of this object.  Keep in mind that</span>
<span class="sd">        the standard library&#39;s :func:`copy` function is a no-op for this class</span>
<span class="sd">        like for any other python immutable type (eg: :class:`tuple`).</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="nb">dict</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__copy__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span>


<span class="k">class</span> <span class="nc">ImmutableMultiDict</span><span class="p">(</span><span class="n">ImmutableMultiDictMixin</span><span class="p">,</span> <span class="n">MultiDict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;An immutable :class:`MultiDict`.</span>

<span class="sd">    .. versionadded:: 0.5</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return a shallow mutable copy of this object.  Keep in mind that</span>
<span class="sd">        the standard library&#39;s :func:`copy` function is a no-op for this class</span>
<span class="sd">        like for any other python immutable type (eg: :class:`tuple`).</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="n">MultiDict</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__copy__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span>


<span class="k">class</span> <span class="nc">ImmutableOrderedMultiDict</span><span class="p">(</span><span class="n">ImmutableMultiDictMixin</span><span class="p">,</span> <span class="n">OrderedMultiDict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;An immutable :class:`OrderedMultiDict`.</span>

<span class="sd">    .. versionadded:: 0.6</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">_iter_hashitems</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">multi</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span>

    <span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return a shallow mutable copy of this object.  Keep in mind that</span>
<span class="sd">        the standard library&#39;s :func:`copy` function is a no-op for this class</span>
<span class="sd">        like for any other python immutable type (eg: :class:`tuple`).</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="n">OrderedMultiDict</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__copy__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span>


<span class="nd">@native_itermethods</span><span class="p">([</span><span class="s1">&#39;values&#39;</span><span class="p">])</span>
<span class="k">class</span> <span class="nc">Accept</span><span class="p">(</span><span class="n">ImmutableList</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;An :class:`Accept` object is just a list subclass for lists of</span>
<span class="sd">    ``(value, quality)`` tuples.  It is automatically sorted by quality.</span>

<span class="sd">    All :class:`Accept` objects work similar to a list but provide extra</span>
<span class="sd">    functionality for working with the data.  Containment checks are</span>
<span class="sd">    normalized to the rules of that header:</span>

<span class="sd">    &gt;&gt;&gt; a = CharsetAccept([(&#39;ISO-8859-1&#39;, 1), (&#39;utf-8&#39;, 0.7)])</span>
<span class="sd">    &gt;&gt;&gt; a.best</span>
<span class="sd">    &#39;ISO-8859-1&#39;</span>
<span class="sd">    &gt;&gt;&gt; &#39;iso-8859-1&#39; in a</span>
<span class="sd">    True</span>
<span class="sd">    &gt;&gt;&gt; &#39;UTF8&#39; in a</span>
<span class="sd">    True</span>
<span class="sd">    &gt;&gt;&gt; &#39;utf7&#39; in a</span>
<span class="sd">    False</span>

<span class="sd">    To get the quality for an item you can use normal item lookup:</span>

<span class="sd">    &gt;&gt;&gt; print a[&#39;utf-8&#39;]</span>
<span class="sd">    0.7</span>
<span class="sd">    &gt;&gt;&gt; a[&#39;utf7&#39;]</span>
<span class="sd">    0</span>

<span class="sd">    .. versionchanged:: 0.5</span>
<span class="sd">       :class:`Accept` objects are forced immutable now.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span><span class="o">=</span><span class="p">()):</span>
        <span class="k">if</span> <span class="n">values</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="nb">list</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">provided</span> <span class="o">=</span> <span class="kc">False</span>
        <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">values</span><span class="p">,</span> <span class="n">Accept</span><span class="p">):</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">provided</span> <span class="o">=</span> <span class="n">values</span><span class="o">.</span><span class="n">provided</span>
            <span class="nb">list</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span><span class="p">)</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">provided</span> <span class="o">=</span> <span class="kc">True</span>
            <span class="n">values</span> <span class="o">=</span> <span class="p">[(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span> <span class="k">for</span> <span class="n">b</span><span class="p">,</span> <span class="n">a</span> <span class="ow">in</span> <span class="n">values</span><span class="p">]</span>
            <span class="n">values</span><span class="o">.</span><span class="n">sort</span><span class="p">()</span>
            <span class="n">values</span><span class="o">.</span><span class="n">reverse</span><span class="p">()</span>
            <span class="nb">list</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="p">[(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span> <span class="k">for</span> <span class="n">b</span><span class="p">,</span> <span class="n">a</span> <span class="ow">in</span> <span class="n">values</span><span class="p">])</span>

    <span class="k">def</span> <span class="nf">_value_matches</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Check if a value matches a given accept item.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="n">item</span> <span class="o">==</span> <span class="s1">&#39;*&#39;</span> <span class="ow">or</span> <span class="n">item</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span> <span class="o">==</span> <span class="n">value</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Besides index lookup (getting item n) you can also pass it a string</span>
<span class="sd">        to get the quality for the item.  If the item is not in the list, the</span>
<span class="sd">        returned quality is ``0``.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">string_types</span><span class="p">):</span>
            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">quality</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
        <span class="k">return</span> <span class="nb">list</span><span class="o">.</span><span class="n">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">quality</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Returns the quality of the key.</span>

<span class="sd">        .. versionadded:: 0.6</span>
<span class="sd">           In previous versions you had to use the item-lookup syntax</span>
<span class="sd">           (eg: ``obj[key]`` instead of ``obj.quality(key)``)</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">for</span> <span class="n">item</span><span class="p">,</span> <span class="n">quality</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_value_matches</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
                <span class="k">return</span> <span class="n">quality</span>
        <span class="k">return</span> <span class="mi">0</span>

    <span class="k">def</span> <span class="nf">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
        <span class="k">for</span> <span class="n">item</span><span class="p">,</span> <span class="n">quality</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_value_matches</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
                <span class="k">return</span> <span class="kc">True</span>
        <span class="k">return</span> <span class="kc">False</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1">([</span><span class="si">%s</span><span class="s1">])&#39;</span> <span class="o">%</span> <span class="p">(</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span>
            <span class="s1">&#39;, &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="s1">&#39;(</span><span class="si">%r</span><span class="s1">, </span><span class="si">%s</span><span class="s1">)&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span> <span class="k">for</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">)</span>
        <span class="p">)</span>

    <span class="k">def</span> <span class="nf">index</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Get the position of an entry or raise :exc:`ValueError`.</span>

<span class="sd">        :param key: The key to be looked up.</span>

<span class="sd">        .. versionchanged:: 0.5</span>
<span class="sd">           This used to raise :exc:`IndexError`, which was inconsistent</span>
<span class="sd">           with the list API.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">string_types</span><span class="p">):</span>
            <span class="k">for</span> <span class="n">idx</span><span class="p">,</span> <span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="n">quality</span><span class="p">)</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
                <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_value_matches</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
                    <span class="k">return</span> <span class="n">idx</span>
            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
        <span class="k">return</span> <span class="nb">list</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">find</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Get the position of an entry or return -1.</span>

<span class="sd">        :param key: The key to be looked up.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
            <span class="k">return</span> <span class="o">-</span><span class="mi">1</span>

    <span class="k">def</span> <span class="nf">values</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Iterate over all values.&quot;&quot;&quot;</span>
        <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="k">yield</span> <span class="n">item</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>

    <span class="k">def</span> <span class="nf">to_header</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Convert the header set into an HTTP header string.&quot;&quot;&quot;</span>
        <span class="n">result</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="k">for</span> <span class="n">value</span><span class="p">,</span> <span class="n">quality</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">quality</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">:</span>
                <span class="n">value</span> <span class="o">=</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1">;q=</span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">quality</span><span class="p">)</span>
            <span class="n">result</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
        <span class="k">return</span> <span class="s1">&#39;,&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">result</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">to_header</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">best_match</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">matches</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Returns the best match from a list of possible matches based</span>
<span class="sd">        on the quality of the client.  If two items have the same quality,</span>
<span class="sd">        the one is returned that comes first.</span>

<span class="sd">        :param matches: a list of matches to check for</span>
<span class="sd">        :param default: the value that is returned if none match</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="n">best_quality</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span>
        <span class="n">result</span> <span class="o">=</span> <span class="n">default</span>
        <span class="k">for</span> <span class="n">server_item</span> <span class="ow">in</span> <span class="n">matches</span><span class="p">:</span>
            <span class="k">for</span> <span class="n">client_item</span><span class="p">,</span> <span class="n">quality</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
                <span class="k">if</span> <span class="n">quality</span> <span class="o">&lt;=</span> <span class="n">best_quality</span><span class="p">:</span>
                    <span class="k">break</span>
                <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_value_matches</span><span class="p">(</span><span class="n">server_item</span><span class="p">,</span> <span class="n">client_item</span><span class="p">)</span> \
                   <span class="ow">and</span> <span class="n">quality</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">:</span>
                    <span class="n">best_quality</span> <span class="o">=</span> <span class="n">quality</span>
                    <span class="n">result</span> <span class="o">=</span> <span class="n">server_item</span>
        <span class="k">return</span> <span class="n">result</span>

    <span class="nd">@property</span>
    <span class="k">def</span> <span class="nf">best</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;The best match as value.&quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="bp">self</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">self</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span>


<span class="k">class</span> <span class="nc">MIMEAccept</span><span class="p">(</span><span class="n">Accept</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Like :class:`Accept` but with special methods and behavior for</span>
<span class="sd">    mimetypes.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">_value_matches</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
        <span class="k">def</span> <span class="nf">_normalize</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
            <span class="n">x</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
            <span class="k">return</span> <span class="n">x</span> <span class="o">==</span> <span class="s1">&#39;*&#39;</span> <span class="ow">and</span> <span class="p">(</span><span class="s1">&#39;*&#39;</span><span class="p">,</span> <span class="s1">&#39;*&#39;</span><span class="p">)</span> <span class="ow">or</span> <span class="n">x</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s1">&#39;/&#39;</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>

        <span class="c1"># this is from the application which is trusted.  to avoid developer</span>
        <span class="c1"># frustration we actually check these for valid values</span>
        <span class="k">if</span> <span class="s1">&#39;/&#39;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">value</span><span class="p">:</span>
            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">&#39;invalid mimetype </span><span class="si">%r</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="n">value</span><span class="p">)</span>
        <span class="n">value_type</span><span class="p">,</span> <span class="n">value_subtype</span> <span class="o">=</span> <span class="n">_normalize</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">value_type</span> <span class="o">==</span> <span class="s1">&#39;*&#39;</span> <span class="ow">and</span> <span class="n">value_subtype</span> <span class="o">!=</span> <span class="s1">&#39;*&#39;</span><span class="p">:</span>
            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">&#39;invalid mimetype </span><span class="si">%r</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="n">value</span><span class="p">)</span>

        <span class="k">if</span> <span class="s1">&#39;/&#39;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">item</span><span class="p">:</span>
            <span class="k">return</span> <span class="kc">False</span>
        <span class="n">item_type</span><span class="p">,</span> <span class="n">item_subtype</span> <span class="o">=</span> <span class="n">_normalize</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">item_type</span> <span class="o">==</span> <span class="s1">&#39;*&#39;</span> <span class="ow">and</span> <span class="n">item_subtype</span> <span class="o">!=</span> <span class="s1">&#39;*&#39;</span><span class="p">:</span>
            <span class="k">return</span> <span class="kc">False</span>
        <span class="k">return</span> <span class="p">(</span>
            <span class="p">(</span><span class="n">item_type</span> <span class="o">==</span> <span class="n">item_subtype</span> <span class="o">==</span> <span class="s1">&#39;*&#39;</span> <span class="ow">or</span>
             <span class="n">value_type</span> <span class="o">==</span> <span class="n">value_subtype</span> <span class="o">==</span> <span class="s1">&#39;*&#39;</span><span class="p">)</span> <span class="ow">or</span>
            <span class="p">(</span><span class="n">item_type</span> <span class="o">==</span> <span class="n">value_type</span> <span class="ow">and</span> <span class="p">(</span><span class="n">item_subtype</span> <span class="o">==</span> <span class="s1">&#39;*&#39;</span> <span class="ow">or</span>
                                          <span class="n">value_subtype</span> <span class="o">==</span> <span class="s1">&#39;*&#39;</span> <span class="ow">or</span>
                                          <span class="n">item_subtype</span> <span class="o">==</span> <span class="n">value_subtype</span><span class="p">))</span>
        <span class="p">)</span>

    <span class="nd">@property</span>
    <span class="k">def</span> <span class="nf">accept_html</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;True if this object accepts HTML.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="p">(</span>
            <span class="s1">&#39;text/html&#39;</span> <span class="ow">in</span> <span class="bp">self</span> <span class="ow">or</span>
            <span class="s1">&#39;application/xhtml+xml&#39;</span> <span class="ow">in</span> <span class="bp">self</span> <span class="ow">or</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">accept_xhtml</span>
        <span class="p">)</span>

    <span class="nd">@property</span>
    <span class="k">def</span> <span class="nf">accept_xhtml</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;True if this object accepts XHTML.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="p">(</span>
            <span class="s1">&#39;application/xhtml+xml&#39;</span> <span class="ow">in</span> <span class="bp">self</span> <span class="ow">or</span>
            <span class="s1">&#39;application/xml&#39;</span> <span class="ow">in</span> <span class="bp">self</span>
        <span class="p">)</span>

    <span class="nd">@property</span>
    <span class="k">def</span> <span class="nf">accept_json</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;True if this object accepts JSON.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="s1">&#39;application/json&#39;</span> <span class="ow">in</span> <span class="bp">self</span>


<span class="k">class</span> <span class="nc">LanguageAccept</span><span class="p">(</span><span class="n">Accept</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Like :class:`Accept` but with normalization for languages.&quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">_value_matches</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
        <span class="k">def</span> <span class="nf">_normalize</span><span class="p">(</span><span class="n">language</span><span class="p">):</span>
            <span class="k">return</span> <span class="n">_locale_delim_re</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="n">language</span><span class="o">.</span><span class="n">lower</span><span class="p">())</span>
        <span class="k">return</span> <span class="n">item</span> <span class="o">==</span> <span class="s1">&#39;*&#39;</span> <span class="ow">or</span> <span class="n">_normalize</span><span class="p">(</span><span class="n">value</span><span class="p">)</span> <span class="o">==</span> <span class="n">_normalize</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">CharsetAccept</span><span class="p">(</span><span class="n">Accept</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Like :class:`Accept` but with normalization for charsets.&quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">_value_matches</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
        <span class="k">def</span> <span class="nf">_normalize</span><span class="p">(</span><span class="n">name</span><span class="p">):</span>
            <span class="k">try</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">codecs</span><span class="o">.</span><span class="n">lookup</span><span class="p">(</span><span class="n">name</span><span class="p">)</span><span class="o">.</span><span class="n">name</span>
            <span class="k">except</span> <span class="ne">LookupError</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">name</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
        <span class="k">return</span> <span class="n">item</span> <span class="o">==</span> <span class="s1">&#39;*&#39;</span> <span class="ow">or</span> <span class="n">_normalize</span><span class="p">(</span><span class="n">value</span><span class="p">)</span> <span class="o">==</span> <span class="n">_normalize</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>


<span class="k">def</span> <span class="nf">cache_property</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">empty</span><span class="p">,</span> <span class="nb">type</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;Return a new property object for a cache header.  Useful if you</span>
<span class="sd">    want to add support for a cache extension in a subclass.&quot;&quot;&quot;</span>
    <span class="k">return</span> <span class="nb">property</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">_get_cache_value</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">empty</span><span class="p">,</span> <span class="nb">type</span><span class="p">),</span>
                    <span class="k">lambda</span> <span class="n">x</span><span class="p">,</span> <span class="n">v</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">_set_cache_value</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="nb">type</span><span class="p">),</span>
                    <span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">_del_cache_value</span><span class="p">(</span><span class="n">key</span><span class="p">),</span>
                    <span class="s1">&#39;accessor for </span><span class="si">%r</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="n">key</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">_CacheControl</span><span class="p">(</span><span class="n">UpdateDictMixin</span><span class="p">,</span> <span class="nb">dict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Subclass of a dict that stores values for a Cache-Control header.  It</span>
<span class="sd">    has accessors for all the cache-control directives specified in RFC 2616.</span>
<span class="sd">    The class does not differentiate between request and response directives.</span>

<span class="sd">    Because the cache-control directives in the HTTP header use dashes the</span>
<span class="sd">    python descriptors use underscores for that.</span>

<span class="sd">    To get a header of the :class:`CacheControl` object again you can convert</span>
<span class="sd">    the object into a string or call the :meth:`to_header` method.  If you plan</span>
<span class="sd">    to subclass it and add your own items have a look at the sourcecode for</span>
<span class="sd">    that class.</span>

<span class="sd">    .. versionchanged:: 0.4</span>

<span class="sd">       Setting `no_cache` or `private` to boolean `True` will set the implicit</span>
<span class="sd">       none-value which is ``*``:</span>

<span class="sd">       &gt;&gt;&gt; cc = ResponseCacheControl()</span>
<span class="sd">       &gt;&gt;&gt; cc.no_cache = True</span>
<span class="sd">       &gt;&gt;&gt; cc</span>
<span class="sd">       &lt;ResponseCacheControl &#39;no-cache&#39;&gt;</span>
<span class="sd">       &gt;&gt;&gt; cc.no_cache</span>
<span class="sd">       &#39;*&#39;</span>
<span class="sd">       &gt;&gt;&gt; cc.no_cache = None</span>
<span class="sd">       &gt;&gt;&gt; cc</span>
<span class="sd">       &lt;ResponseCacheControl &#39;&#39;&gt;</span>

<span class="sd">       In versions before 0.5 the behavior documented here affected the now</span>
<span class="sd">       no longer existing `CacheControl` class.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="n">no_cache</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;no-cache&#39;</span><span class="p">,</span> <span class="s1">&#39;*&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
    <span class="n">no_store</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;no-store&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">bool</span><span class="p">)</span>
    <span class="n">max_age</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;max-age&#39;</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="nb">int</span><span class="p">)</span>
    <span class="n">no_transform</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;no-transform&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span><span class="o">=</span><span class="p">(),</span> <span class="n">on_update</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span> <span class="ow">or</span> <span class="p">())</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="o">=</span> <span class="n">on_update</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">provided</span> <span class="o">=</span> <span class="n">values</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span>

    <span class="k">def</span> <span class="nf">_get_cache_value</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">empty</span><span class="p">,</span> <span class="nb">type</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Used internally by the accessor properties.&quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="nb">type</span> <span class="ow">is</span> <span class="nb">bool</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span>
        <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="n">value</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
            <span class="k">if</span> <span class="n">value</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">empty</span>
            <span class="k">elif</span> <span class="nb">type</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
                <span class="k">try</span><span class="p">:</span>
                    <span class="n">value</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
                <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
                    <span class="k">pass</span>
            <span class="k">return</span> <span class="n">value</span>

    <span class="k">def</span> <span class="nf">_set_cache_value</span><span class="p">(</span><span class="bp">self</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="nb">type</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Used internally by the accessor properties.&quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="nb">type</span> <span class="ow">is</span> <span class="nb">bool</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">value</span><span class="p">:</span>
                <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">value</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
            <span class="k">elif</span> <span class="n">value</span> <span class="ow">is</span> <span class="kc">True</span><span class="p">:</span>
                <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>

    <span class="k">def</span> <span class="nf">_del_cache_value</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Used internally by the accessor properties.&quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
            <span class="k">del</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>

    <span class="k">def</span> <span class="nf">to_header</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Convert the stored values into a cache control header.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="n">dump_header</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">to_header</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;&lt;</span><span class="si">%s</span><span class="s1"> </span><span class="si">%s</span><span class="s1">&gt;&#39;</span> <span class="o">%</span> <span class="p">(</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span>
            <span class="s2">&quot; &quot;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span>
                <span class="s2">&quot;</span><span class="si">%s</span><span class="s2">=</span><span class="si">%r</span><span class="s2">&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="n">k</span><span class="p">,</span> <span class="n">v</span><span class="p">)</span> <span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>
            <span class="p">),</span>
        <span class="p">)</span>


<span class="k">class</span> <span class="nc">RequestCacheControl</span><span class="p">(</span><span class="n">ImmutableDictMixin</span><span class="p">,</span> <span class="n">_CacheControl</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;A cache control for requests.  This is immutable and gives access</span>
<span class="sd">    to all the request-relevant cache control headers.</span>

<span class="sd">    To get a header of the :class:`RequestCacheControl` object again you can</span>
<span class="sd">    convert the object into a string or call the :meth:`to_header` method.  If</span>
<span class="sd">    you plan to subclass it and add your own items have a look at the sourcecode</span>
<span class="sd">    for that class.</span>

<span class="sd">    .. versionadded:: 0.5</span>
<span class="sd">       In previous versions a `CacheControl` class existed that was used</span>
<span class="sd">       both for request and response.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="n">max_stale</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;max-stale&#39;</span><span class="p">,</span> <span class="s1">&#39;*&#39;</span><span class="p">,</span> <span class="nb">int</span><span class="p">)</span>
    <span class="n">min_fresh</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;min-fresh&#39;</span><span class="p">,</span> <span class="s1">&#39;*&#39;</span><span class="p">,</span> <span class="nb">int</span><span class="p">)</span>
    <span class="n">no_transform</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;no-transform&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
    <span class="n">only_if_cached</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;only-if-cached&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">bool</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">ResponseCacheControl</span><span class="p">(</span><span class="n">_CacheControl</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;A cache control for responses.  Unlike :class:`RequestCacheControl`</span>
<span class="sd">    this is mutable and gives access to response-relevant cache control</span>
<span class="sd">    headers.</span>

<span class="sd">    To get a header of the :class:`ResponseCacheControl` object again you can</span>
<span class="sd">    convert the object into a string or call the :meth:`to_header` method.  If</span>
<span class="sd">    you plan to subclass it and add your own items have a look at the sourcecode</span>
<span class="sd">    for that class.</span>

<span class="sd">    .. versionadded:: 0.5</span>
<span class="sd">       In previous versions a `CacheControl` class existed that was used</span>
<span class="sd">       both for request and response.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="n">public</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;public&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">bool</span><span class="p">)</span>
    <span class="n">private</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;private&#39;</span><span class="p">,</span> <span class="s1">&#39;*&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
    <span class="n">must_revalidate</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;must-revalidate&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">bool</span><span class="p">)</span>
    <span class="n">proxy_revalidate</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;proxy-revalidate&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">bool</span><span class="p">)</span>
    <span class="n">s_maxage</span> <span class="o">=</span> <span class="n">cache_property</span><span class="p">(</span><span class="s1">&#39;s-maxage&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>


<span class="c1"># attach cache_property to the _CacheControl as staticmethod</span>
<span class="c1"># so that others can reuse it.</span>
<span class="n">_CacheControl</span><span class="o">.</span><span class="n">cache_property</span> <span class="o">=</span> <span class="nb">staticmethod</span><span class="p">(</span><span class="n">cache_property</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">CallbackDict</span><span class="p">(</span><span class="n">UpdateDictMixin</span><span class="p">,</span> <span class="nb">dict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;A dict that calls a function passed every time something is changed.</span>
<span class="sd">    The function is passed the dict instance.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">initial</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">on_update</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">initial</span> <span class="ow">or</span> <span class="p">())</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="o">=</span> <span class="n">on_update</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;&lt;</span><span class="si">%s</span><span class="s1"> </span><span class="si">%s</span><span class="s1">&gt;&#39;</span> <span class="o">%</span> <span class="p">(</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span>
            <span class="nb">dict</span><span class="o">.</span><span class="n">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="p">)</span>


<span class="k">class</span> <span class="nc">HeaderSet</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Similar to the :class:`ETags` class this implements a set-like structure.</span>
<span class="sd">    Unlike :class:`ETags` this is case insensitive and used for vary, allow, and</span>
<span class="sd">    content-language headers.</span>

<span class="sd">    If not constructed using the :func:`parse_set_header` function the</span>
<span class="sd">    instantiation works like this:</span>

<span class="sd">    &gt;&gt;&gt; hs = HeaderSet([&#39;foo&#39;, &#39;bar&#39;, &#39;baz&#39;])</span>
<span class="sd">    &gt;&gt;&gt; hs</span>
<span class="sd">    HeaderSet([&#39;foo&#39;, &#39;bar&#39;, &#39;baz&#39;])</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">headers</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">on_update</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_headers</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">headers</span> <span class="ow">or</span> <span class="p">())</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_set</span> <span class="o">=</span> <span class="nb">set</span><span class="p">([</span><span class="n">x</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="p">])</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="o">=</span> <span class="n">on_update</span>

    <span class="k">def</span> <span class="nf">add</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">header</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Add a new header to the set.&quot;&quot;&quot;</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">update</span><span class="p">((</span><span class="n">header</span><span class="p">,))</span>

    <span class="k">def</span> <span class="nf">remove</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">header</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Remove a header from the set.  This raises an :exc:`KeyError` if the</span>
<span class="sd">        header is not in the set.</span>

<span class="sd">        .. versionchanged:: 0.5</span>
<span class="sd">            In older versions a :exc:`IndexError` was raised instead of a</span>
<span class="sd">            :exc:`KeyError` if the object was missing.</span>

<span class="sd">        :param header: the header to be removed.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="n">key</span> <span class="o">=</span> <span class="n">header</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
        <span class="k">if</span> <span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_set</span><span class="p">:</span>
            <span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="n">header</span><span class="p">)</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_set</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
        <span class="k">for</span> <span class="n">idx</span><span class="p">,</span> <span class="n">key</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="p">):</span>
            <span class="k">if</span> <span class="n">key</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span> <span class="o">==</span> <span class="n">header</span><span class="p">:</span>
                <span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="p">[</span><span class="n">idx</span><span class="p">]</span>
                <span class="k">break</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">iterable</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Add all the headers from the iterable to the set.</span>

<span class="sd">        :param iterable: updates the set with the items from the iterable.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="n">inserted_any</span> <span class="o">=</span> <span class="kc">False</span>
        <span class="k">for</span> <span class="n">header</span> <span class="ow">in</span> <span class="n">iterable</span><span class="p">:</span>
            <span class="n">key</span> <span class="o">=</span> <span class="n">header</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
            <span class="k">if</span> <span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_set</span><span class="p">:</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">header</span><span class="p">)</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">_set</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
                <span class="n">inserted_any</span> <span class="o">=</span> <span class="kc">True</span>
        <span class="k">if</span> <span class="n">inserted_any</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">discard</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">header</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Like :meth:`remove` but ignores errors.</span>

<span class="sd">        :param header: the header to be discarded.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="n">header</span><span class="p">)</span>
        <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
            <span class="k">pass</span>

    <span class="k">def</span> <span class="nf">find</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">header</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return the index of the header in the set or return -1 if not found.</span>

<span class="sd">        :param header: the header to be looked up.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="n">header</span> <span class="o">=</span> <span class="n">header</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>
        <span class="k">for</span> <span class="n">idx</span><span class="p">,</span> <span class="n">item</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="p">):</span>
            <span class="k">if</span> <span class="n">item</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span> <span class="o">==</span> <span class="n">header</span><span class="p">:</span>
                <span class="k">return</span> <span class="n">idx</span>
        <span class="k">return</span> <span class="o">-</span><span class="mi">1</span>

    <span class="k">def</span> <span class="nf">index</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">header</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return the index of the header in the set or raise an</span>
<span class="sd">        :exc:`IndexError`.</span>

<span class="sd">        :param header: the header to be looked up.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="n">rv</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">find</span><span class="p">(</span><span class="n">header</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">rv</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
            <span class="k">raise</span> <span class="ne">IndexError</span><span class="p">(</span><span class="n">header</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">rv</span>

    <span class="k">def</span> <span class="nf">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Clear the set.&quot;&quot;&quot;</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_set</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
        <span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="p">[:]</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">as_set</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">preserve_casing</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Return the set as real python set type.  When calling this, all</span>
<span class="sd">        the items are converted to lowercase and the ordering is lost.</span>

<span class="sd">        :param preserve_casing: if set to `True` the items in the set returned</span>
<span class="sd">                                will have the original case like in the</span>
<span class="sd">                                :class:`HeaderSet`, otherwise they will</span>
<span class="sd">                                be lowercase.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="n">preserve_casing</span><span class="p">:</span>
            <span class="k">return</span> <span class="nb">set</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="p">)</span>
        <span class="k">return</span> <span class="nb">set</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_set</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">to_header</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Convert the header set into an HTTP header string.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="s1">&#39;, &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">quote_header_value</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="p">))</span>

    <span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">idx</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="p">[</span><span class="n">idx</span><span class="p">]</span>

    <span class="k">def</span> <span class="nf">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">idx</span><span class="p">):</span>
        <span class="n">rv</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">idx</span><span class="p">)</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_set</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="n">rv</span><span class="o">.</span><span class="n">lower</span><span class="p">())</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">idx</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
        <span class="n">old</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="p">[</span><span class="n">idx</span><span class="p">]</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_set</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="n">old</span><span class="o">.</span><span class="n">lower</span><span class="p">())</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="p">[</span><span class="n">idx</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_set</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">value</span><span class="o">.</span><span class="n">lower</span><span class="p">())</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">header</span><span class="p">):</span>
        <span class="k">return</span> <span class="n">header</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_set</span>

    <span class="k">def</span> <span class="nf">__len__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_set</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">iter</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_headers</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__nonzero__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">bool</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_set</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">to_header</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1">(</span><span class="si">%r</span><span class="s1">)&#39;</span> <span class="o">%</span> <span class="p">(</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">_headers</span>
        <span class="p">)</span>


<span class="k">class</span> <span class="nc">ETags</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;A set that can be used to check if one etag is present in a collection</span>
<span class="sd">    of etags.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">strong_etags</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">weak_etags</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">star_tag</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_strong</span> <span class="o">=</span> <span class="nb">frozenset</span><span class="p">(</span><span class="ow">not</span> <span class="n">star_tag</span> <span class="ow">and</span> <span class="n">strong_etags</span> <span class="ow">or</span> <span class="p">())</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_weak</span> <span class="o">=</span> <span class="nb">frozenset</span><span class="p">(</span><span class="n">weak_etags</span> <span class="ow">or</span> <span class="p">())</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">star_tag</span> <span class="o">=</span> <span class="n">star_tag</span>

    <span class="k">def</span> <span class="nf">as_set</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">include_weak</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Convert the `ETags` object into a python set.  Per default all the</span>
<span class="sd">        weak etags are not part of this set.&quot;&quot;&quot;</span>
        <span class="n">rv</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_strong</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">include_weak</span><span class="p">:</span>
            <span class="n">rv</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_weak</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">rv</span>

    <span class="k">def</span> <span class="nf">is_weak</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">etag</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Check if an etag is weak.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="n">etag</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_weak</span>

    <span class="k">def</span> <span class="nf">contains_weak</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">etag</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Check if an etag is part of the set including weak and strong tags.&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">is_weak</span><span class="p">(</span><span class="n">etag</span><span class="p">)</span> <span class="ow">or</span> <span class="bp">self</span><span class="o">.</span><span class="n">contains</span><span class="p">(</span><span class="n">etag</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">contains</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">etag</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Check if an etag is part of the set ignoring weak tags.</span>
<span class="sd">        It is also possible to use the ``in`` operator.</span>

<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">star_tag</span><span class="p">:</span>
            <span class="k">return</span> <span class="kc">True</span>
        <span class="k">return</span> <span class="n">etag</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_strong</span>

    <span class="k">def</span> <span class="nf">contains_raw</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">etag</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;When passed a quoted tag it will check if this tag is part of the</span>
<span class="sd">        set.  If the tag is weak it is checked against weak and strong tags,</span>
<span class="sd">        otherwise strong only.&quot;&quot;&quot;</span>
        <span class="n">etag</span><span class="p">,</span> <span class="n">weak</span> <span class="o">=</span> <span class="n">unquote_etag</span><span class="p">(</span><span class="n">etag</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">weak</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">contains_weak</span><span class="p">(</span><span class="n">etag</span><span class="p">)</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">contains</span><span class="p">(</span><span class="n">etag</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">to_header</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Convert the etags set into a HTTP header string.&quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">star_tag</span><span class="p">:</span>
            <span class="k">return</span> <span class="s1">&#39;*&#39;</span>
        <span class="k">return</span> <span class="s1">&#39;, &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span>
            <span class="p">[</span><span class="s1">&#39;&quot;</span><span class="si">%s</span><span class="s1">&quot;&#39;</span> <span class="o">%</span> <span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_strong</span><span class="p">]</span> <span class="o">+</span>
            <span class="p">[</span><span class="s1">&#39;W/&quot;</span><span class="si">%s</span><span class="s1">&quot;&#39;</span> <span class="o">%</span> <span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_weak</span><span class="p">]</span>
        <span class="p">)</span>

    <span class="k">def</span> <span class="nf">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">etag</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">data</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">include_weak</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="k">if</span> <span class="p">[</span><span class="n">etag</span><span class="p">,</span> <span class="n">data</span><span class="p">]</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="kc">None</span><span class="p">)</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">:</span>
            <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">&#39;either tag or data required, but at least one&#39;</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">etag</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="n">etag</span> <span class="o">=</span> <span class="n">generate_etag</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">include_weak</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">etag</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_weak</span><span class="p">:</span>
                <span class="k">return</span> <span class="kc">True</span>
        <span class="k">return</span> <span class="n">etag</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_strong</span>

    <span class="k">def</span> <span class="nf">__bool__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">bool</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">star_tag</span> <span class="ow">or</span> <span class="bp">self</span><span class="o">.</span><span class="n">_strong</span> <span class="ow">or</span> <span class="bp">self</span><span class="o">.</span><span class="n">_weak</span><span class="p">)</span>

    <span class="n">__nonzero__</span> <span class="o">=</span> <span class="n">__bool__</span>

    <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">to_header</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">iter</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_strong</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">etag</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">contains</span><span class="p">(</span><span class="n">etag</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;&lt;</span><span class="si">%s</span><span class="s1"> </span><span class="si">%r</span><span class="s1">&gt;&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="nb">str</span><span class="p">(</span><span class="bp">self</span><span class="p">))</span>


<span class="k">class</span> <span class="nc">IfRange</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Very simple object that represents the `If-Range` header in parsed</span>
<span class="sd">    form.  It will either have neither a etag or date or one of either but</span>
<span class="sd">    never both.</span>

<span class="sd">    .. versionadded:: 0.7</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">etag</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">date</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="c1">#: The etag parsed and unquoted.  Ranges always operate on strong</span>
        <span class="c1">#: etags so the weakness information is not necessary.</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">etag</span> <span class="o">=</span> <span class="n">etag</span>
        <span class="c1">#: The date in parsed format or `None`.</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">date</span> <span class="o">=</span> <span class="n">date</span>

    <span class="k">def</span> <span class="nf">to_header</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Converts the object back into an HTTP header.&quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">date</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">http_date</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">date</span><span class="p">)</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">etag</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">quote_etag</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">etag</span><span class="p">)</span>
        <span class="k">return</span> <span class="s1">&#39;&#39;</span>

    <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">to_header</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;&lt;</span><span class="si">%s</span><span class="s1"> </span><span class="si">%r</span><span class="s1">&gt;&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="nb">str</span><span class="p">(</span><span class="bp">self</span><span class="p">))</span>


<span class="k">class</span> <span class="nc">Range</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Represents a range header.  All the methods are only supporting bytes</span>
<span class="sd">    as unit.  It does store multiple ranges but :meth:`range_for_length` will</span>
<span class="sd">    only work if only one range is provided.</span>

<span class="sd">    .. versionadded:: 0.7</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">units</span><span class="p">,</span> <span class="n">ranges</span><span class="p">):</span>
        <span class="c1">#: The units of this range.  Usually &quot;bytes&quot;.</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="n">units</span>
        <span class="c1">#: A list of ``(begin, end)`` tuples for the range header provided.</span>
        <span class="c1">#: The ranges are non-inclusive.</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">ranges</span> <span class="o">=</span> <span class="n">ranges</span>

    <span class="k">def</span> <span class="nf">range_for_length</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">length</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;If the range is for bytes, the length is not None and there is</span>
<span class="sd">        exactly one range and it is satisfiable it returns a ``(start, stop)``</span>
<span class="sd">        tuple, otherwise `None`.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">units</span> <span class="o">!=</span> <span class="s1">&#39;bytes&#39;</span> <span class="ow">or</span> <span class="n">length</span> <span class="ow">is</span> <span class="kc">None</span> <span class="ow">or</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">ranges</span><span class="p">)</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">:</span>
            <span class="k">return</span> <span class="kc">None</span>
        <span class="n">start</span><span class="p">,</span> <span class="n">end</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">ranges</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
        <span class="k">if</span> <span class="n">end</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="n">end</span> <span class="o">=</span> <span class="n">length</span>
            <span class="k">if</span> <span class="n">start</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
                <span class="n">start</span> <span class="o">+=</span> <span class="n">length</span>
        <span class="k">if</span> <span class="n">is_byte_range_valid</span><span class="p">(</span><span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">,</span> <span class="n">length</span><span class="p">):</span>
            <span class="k">return</span> <span class="n">start</span><span class="p">,</span> <span class="nb">min</span><span class="p">(</span><span class="n">end</span><span class="p">,</span> <span class="n">length</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">make_content_range</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">length</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Creates a :class:`~werkzeug.datastructures.ContentRange` object</span>
<span class="sd">        from the current range and given content length.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="n">rng</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">range_for_length</span><span class="p">(</span><span class="n">length</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">rng</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">ContentRange</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">units</span><span class="p">,</span> <span class="n">rng</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">rng</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">length</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">to_header</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Converts the object back into an HTTP header.&quot;&quot;&quot;</span>
        <span class="n">ranges</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="k">for</span> <span class="n">begin</span><span class="p">,</span> <span class="n">end</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">ranges</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">end</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
                <span class="n">ranges</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">begin</span> <span class="o">&gt;=</span> <span class="mi">0</span> <span class="ow">and</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1">-&#39;</span> <span class="o">%</span> <span class="n">begin</span> <span class="ow">or</span> <span class="nb">str</span><span class="p">(</span><span class="n">begin</span><span class="p">))</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="n">ranges</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="s1">&#39;</span><span class="si">%s</span><span class="s1">-</span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">begin</span><span class="p">,</span> <span class="n">end</span> <span class="o">-</span> <span class="mi">1</span><span class="p">))</span>
        <span class="k">return</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1">=</span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">units</span><span class="p">,</span> <span class="s1">&#39;,&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">ranges</span><span class="p">))</span>

    <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">to_header</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;&lt;</span><span class="si">%s</span><span class="s1"> </span><span class="si">%r</span><span class="s1">&gt;&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="nb">str</span><span class="p">(</span><span class="bp">self</span><span class="p">))</span>


<span class="k">class</span> <span class="nc">ContentRange</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Represents the content range header.</span>

<span class="sd">    .. versionadded:: 0.7</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">units</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">stop</span><span class="p">,</span> <span class="n">length</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">on_update</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="k">assert</span> <span class="n">is_byte_range_valid</span><span class="p">(</span><span class="n">start</span><span class="p">,</span> <span class="n">stop</span><span class="p">,</span> <span class="n">length</span><span class="p">),</span> \
            <span class="s1">&#39;Bad range provided&#39;</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="o">=</span> <span class="n">on_update</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">start</span><span class="p">,</span> <span class="n">stop</span><span class="p">,</span> <span class="n">length</span><span class="p">,</span> <span class="n">units</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">_callback_property</span><span class="p">(</span><span class="n">name</span><span class="p">):</span>
        <span class="k">def</span> <span class="nf">fget</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
            <span class="k">return</span> <span class="nb">getattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>

        <span class="k">def</span> <span class="nf">fset</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
            <span class="nb">setattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
            <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="k">return</span> <span class="nb">property</span><span class="p">(</span><span class="n">fget</span><span class="p">,</span> <span class="n">fset</span><span class="p">)</span>

    <span class="c1">#: The units to use, usually &quot;bytes&quot;</span>
    <span class="n">units</span> <span class="o">=</span> <span class="n">_callback_property</span><span class="p">(</span><span class="s1">&#39;_units&#39;</span><span class="p">)</span>
    <span class="c1">#: The start point of the range or `None`.</span>
    <span class="n">start</span> <span class="o">=</span> <span class="n">_callback_property</span><span class="p">(</span><span class="s1">&#39;_start&#39;</span><span class="p">)</span>
    <span class="c1">#: The stop point of the range (non-inclusive) or `None`.  Can only be</span>
    <span class="c1">#: `None` if also start is `None`.</span>
    <span class="n">stop</span> <span class="o">=</span> <span class="n">_callback_property</span><span class="p">(</span><span class="s1">&#39;_stop&#39;</span><span class="p">)</span>
    <span class="c1">#: The length of the range or `None`.</span>
    <span class="n">length</span> <span class="o">=</span> <span class="n">_callback_property</span><span class="p">(</span><span class="s1">&#39;_length&#39;</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">set</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">stop</span><span class="p">,</span> <span class="n">length</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">units</span><span class="o">=</span><span class="s1">&#39;bytes&#39;</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Simple method to update the ranges.&quot;&quot;&quot;</span>
        <span class="k">assert</span> <span class="n">is_byte_range_valid</span><span class="p">(</span><span class="n">start</span><span class="p">,</span> <span class="n">stop</span><span class="p">,</span> <span class="n">length</span><span class="p">),</span> \
            <span class="s1">&#39;Bad range provided&#39;</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_units</span> <span class="o">=</span> <span class="n">units</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_start</span> <span class="o">=</span> <span class="n">start</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_stop</span> <span class="o">=</span> <span class="n">stop</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_length</span> <span class="o">=</span> <span class="n">length</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">unset</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Sets the units to `None` which indicates that the header should</span>
<span class="sd">        no longer be used.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="n">units</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">to_header</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">units</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">return</span> <span class="s1">&#39;&#39;</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">length</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="n">length</span> <span class="o">=</span> <span class="s1">&#39;*&#39;</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="n">length</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">length</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">start</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">return</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1"> */</span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">units</span><span class="p">,</span> <span class="n">length</span><span class="p">)</span>
        <span class="k">return</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1"> </span><span class="si">%s</span><span class="s1">-</span><span class="si">%s</span><span class="s1">/</span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">units</span><span class="p">,</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">start</span><span class="p">,</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">stop</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span>
            <span class="n">length</span>
        <span class="p">)</span>

    <span class="k">def</span> <span class="nf">__nonzero__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">units</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span>

    <span class="n">__bool__</span> <span class="o">=</span> <span class="n">__nonzero__</span>

    <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">to_header</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;&lt;</span><span class="si">%s</span><span class="s1"> </span><span class="si">%r</span><span class="s1">&gt;&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="nb">str</span><span class="p">(</span><span class="bp">self</span><span class="p">))</span>


<span class="k">class</span> <span class="nc">Authorization</span><span class="p">(</span><span class="n">ImmutableDictMixin</span><span class="p">,</span> <span class="nb">dict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Represents an `Authorization` header sent by the client.  You should</span>
<span class="sd">    not create this kind of object yourself but use it when it&#39;s returned by</span>
<span class="sd">    the `parse_authorization_header` function.</span>

<span class="sd">    This object is a dict subclass and can be altered by setting dict items</span>
<span class="sd">    but it should be considered immutable as it&#39;s returned by the client and</span>
<span class="sd">    not meant for modifications.</span>

<span class="sd">    .. versionchanged:: 0.5</span>
<span class="sd">       This object became immutable.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">auth_type</span><span class="p">,</span> <span class="n">data</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span> <span class="ow">or</span> <span class="p">{})</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">type</span> <span class="o">=</span> <span class="n">auth_type</span>

    <span class="n">username</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;username&#39;</span><span class="p">),</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        The username transmitted.  This is set for both basic and digest</span>
<span class="s1">        auth all the time.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">password</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;password&#39;</span><span class="p">),</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        When the authentication type is basic this is the password</span>
<span class="s1">        transmitted by the client, else `None`.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">realm</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;realm&#39;</span><span class="p">),</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        This is the server realm sent back for HTTP digest auth.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">nonce</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;nonce&#39;</span><span class="p">),</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        The nonce the server sent for digest auth, sent back by the client.</span>
<span class="s1">        A nonce should be unique for every 401 response for HTTP digest</span>
<span class="s1">        auth.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">uri</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;uri&#39;</span><span class="p">),</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        The URI from Request-URI of the Request-Line; duplicated because</span>
<span class="s1">        proxies are allowed to change the Request-Line in transit.  HTTP</span>
<span class="s1">        digest auth only.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">nc</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;nc&#39;</span><span class="p">),</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        The nonce count value transmitted by clients if a qop-header is</span>
<span class="s1">        also transmitted.  HTTP digest auth only.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">cnonce</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;cnonce&#39;</span><span class="p">),</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        If the server sent a qop-header in the ``WWW-Authenticate``</span>
<span class="s1">        header, the client has to provide this value for HTTP digest auth.</span>
<span class="s1">        See the RFC for more details.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">response</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;response&#39;</span><span class="p">),</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        A string of 32 hex digits computed as defined in RFC 2617, which</span>
<span class="s1">        proves that the user knows a password.  Digest auth only.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">opaque</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;opaque&#39;</span><span class="p">),</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        The opaque header from the server returned unchanged by the client.</span>
<span class="s1">        It is recommended that this string be base64 or hexadecimal data.</span>
<span class="s1">        Digest auth only.&#39;&#39;&#39;</span><span class="p">)</span>

    <span class="nd">@property</span>
    <span class="k">def</span> <span class="nf">qop</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Indicates what &quot;quality of protection&quot; the client has applied to</span>
<span class="sd">        the message for HTTP digest auth.&quot;&quot;&quot;</span>
        <span class="k">def</span> <span class="nf">on_update</span><span class="p">(</span><span class="n">header_set</span><span class="p">):</span>
            <span class="k">if</span> <span class="ow">not</span> <span class="n">header_set</span> <span class="ow">and</span> <span class="s1">&#39;qop&#39;</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
                <span class="k">del</span> <span class="bp">self</span><span class="p">[</span><span class="s1">&#39;qop&#39;</span><span class="p">]</span>
            <span class="k">elif</span> <span class="n">header_set</span><span class="p">:</span>
                <span class="bp">self</span><span class="p">[</span><span class="s1">&#39;qop&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">header_set</span><span class="o">.</span><span class="n">to_header</span><span class="p">()</span>
        <span class="k">return</span> <span class="n">parse_set_header</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;qop&#39;</span><span class="p">),</span> <span class="n">on_update</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">WWWAuthenticate</span><span class="p">(</span><span class="n">UpdateDictMixin</span><span class="p">,</span> <span class="nb">dict</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Provides simple access to `WWW-Authenticate` headers.&quot;&quot;&quot;</span>

    <span class="c1">#: list of keys that require quoting in the generated header</span>
    <span class="n">_require_quoting</span> <span class="o">=</span> <span class="nb">frozenset</span><span class="p">([</span><span class="s1">&#39;domain&#39;</span><span class="p">,</span> <span class="s1">&#39;nonce&#39;</span><span class="p">,</span> <span class="s1">&#39;opaque&#39;</span><span class="p">,</span> <span class="s1">&#39;realm&#39;</span><span class="p">,</span> <span class="s1">&#39;qop&#39;</span><span class="p">])</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">auth_type</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">values</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">on_update</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span> <span class="ow">or</span> <span class="p">())</span>
        <span class="k">if</span> <span class="n">auth_type</span><span class="p">:</span>
            <span class="bp">self</span><span class="p">[</span><span class="s1">&#39;__auth_type__&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">auth_type</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span> <span class="o">=</span> <span class="n">on_update</span>

    <span class="k">def</span> <span class="nf">set_basic</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">realm</span><span class="o">=</span><span class="s1">&#39;authentication required&#39;</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Clear the auth info and enable basic auth.&quot;&quot;&quot;</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="p">{</span><span class="s1">&#39;__auth_type__&#39;</span><span class="p">:</span> <span class="s1">&#39;basic&#39;</span><span class="p">,</span> <span class="s1">&#39;realm&#39;</span><span class="p">:</span> <span class="n">realm</span><span class="p">})</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">set_digest</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">realm</span><span class="p">,</span> <span class="n">nonce</span><span class="p">,</span> <span class="n">qop</span><span class="o">=</span><span class="p">(</span><span class="s1">&#39;auth&#39;</span><span class="p">,),</span> <span class="n">opaque</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
                   <span class="n">algorithm</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">stale</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Clear the auth info and enable digest auth.&quot;&quot;&quot;</span>
        <span class="n">d</span> <span class="o">=</span> <span class="p">{</span>
            <span class="s1">&#39;__auth_type__&#39;</span><span class="p">:</span>    <span class="s1">&#39;digest&#39;</span><span class="p">,</span>
            <span class="s1">&#39;realm&#39;</span><span class="p">:</span>            <span class="n">realm</span><span class="p">,</span>
            <span class="s1">&#39;nonce&#39;</span><span class="p">:</span>            <span class="n">nonce</span><span class="p">,</span>
            <span class="s1">&#39;qop&#39;</span><span class="p">:</span>              <span class="n">dump_header</span><span class="p">(</span><span class="n">qop</span><span class="p">)</span>
        <span class="p">}</span>
        <span class="k">if</span> <span class="n">stale</span><span class="p">:</span>
            <span class="n">d</span><span class="p">[</span><span class="s1">&#39;stale&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;TRUE&#39;</span>
        <span class="k">if</span> <span class="n">opaque</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="n">d</span><span class="p">[</span><span class="s1">&#39;opaque&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">opaque</span>
        <span class="k">if</span> <span class="n">algorithm</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="n">d</span><span class="p">[</span><span class="s1">&#39;algorithm&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">algorithm</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="nb">dict</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">d</span><span class="p">)</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">on_update</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">to_header</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Convert the stored values into a WWW-Authenticate header.&quot;&quot;&quot;</span>
        <span class="n">d</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
        <span class="n">auth_type</span> <span class="o">=</span> <span class="n">d</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="s1">&#39;__auth_type__&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span> <span class="ow">or</span> <span class="s1">&#39;basic&#39;</span>
        <span class="k">return</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1"> </span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">auth_type</span><span class="o">.</span><span class="n">title</span><span class="p">(),</span> <span class="s1">&#39;, &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">([</span>
            <span class="s1">&#39;</span><span class="si">%s</span><span class="s1">=</span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">quote_header_value</span><span class="p">(</span><span class="n">value</span><span class="p">,</span>
                                               <span class="n">allow_token</span><span class="o">=</span><span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_require_quoting</span><span class="p">))</span>
            <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">iteritems</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>
        <span class="p">]))</span>

    <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">to_header</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;&lt;</span><span class="si">%s</span><span class="s1"> </span><span class="si">%r</span><span class="s1">&gt;&#39;</span> <span class="o">%</span> <span class="p">(</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">to_header</span><span class="p">()</span>
        <span class="p">)</span>

    <span class="k">def</span> <span class="nf">auth_property</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;A static helper function for subclasses to add extra authentication</span>
<span class="sd">        system properties onto a class::</span>

<span class="sd">            class FooAuthenticate(WWWAuthenticate):</span>
<span class="sd">                special_realm = auth_property(&#39;special_realm&#39;)</span>

<span class="sd">        For more information have a look at the sourcecode to see how the</span>
<span class="sd">        regular properties (:attr:`realm` etc.) are implemented.</span>
<span class="sd">        &quot;&quot;&quot;</span>

        <span class="k">def</span> <span class="nf">_set_value</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
            <span class="k">if</span> <span class="n">value</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
                <span class="bp">self</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="bp">self</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
        <span class="k">return</span> <span class="nb">property</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">name</span><span class="p">),</span> <span class="n">_set_value</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="n">doc</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">_set_property</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="k">def</span> <span class="nf">fget</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
            <span class="k">def</span> <span class="nf">on_update</span><span class="p">(</span><span class="n">header_set</span><span class="p">):</span>
                <span class="k">if</span> <span class="ow">not</span> <span class="n">header_set</span> <span class="ow">and</span> <span class="n">name</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
                    <span class="k">del</span> <span class="bp">self</span><span class="p">[</span><span class="n">name</span><span class="p">]</span>
                <span class="k">elif</span> <span class="n">header_set</span><span class="p">:</span>
                    <span class="bp">self</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">header_set</span><span class="o">.</span><span class="n">to_header</span><span class="p">()</span>
            <span class="k">return</span> <span class="n">parse_set_header</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">name</span><span class="p">),</span> <span class="n">on_update</span><span class="p">)</span>
        <span class="k">return</span> <span class="nb">property</span><span class="p">(</span><span class="n">fget</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="n">doc</span><span class="p">)</span>

    <span class="nb">type</span> <span class="o">=</span> <span class="n">auth_property</span><span class="p">(</span><span class="s1">&#39;__auth_type__&#39;</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        The type of the auth mechanism.  HTTP currently specifies</span>
<span class="s1">        `Basic` and `Digest`.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">realm</span> <span class="o">=</span> <span class="n">auth_property</span><span class="p">(</span><span class="s1">&#39;realm&#39;</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        A string to be displayed to users so they know which username and</span>
<span class="s1">        password to use.  This string should contain at least the name of</span>
<span class="s1">        the host performing the authentication and might additionally</span>
<span class="s1">        indicate the collection of users who might have access.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">domain</span> <span class="o">=</span> <span class="n">_set_property</span><span class="p">(</span><span class="s1">&#39;domain&#39;</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        A list of URIs that define the protection space.  If a URI is an</span>
<span class="s1">        absolute path, it is relative to the canonical root URL of the</span>
<span class="s1">        server being accessed.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">nonce</span> <span class="o">=</span> <span class="n">auth_property</span><span class="p">(</span><span class="s1">&#39;nonce&#39;</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        A server-specified data string which should be uniquely generated</span>
<span class="s1">        each time a 401 response is made.  It is recommended that this</span>
<span class="s1">        string be base64 or hexadecimal data.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">opaque</span> <span class="o">=</span> <span class="n">auth_property</span><span class="p">(</span><span class="s1">&#39;opaque&#39;</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        A string of data, specified by the server, which should be returned</span>
<span class="s1">        by the client unchanged in the Authorization header of subsequent</span>
<span class="s1">        requests with URIs in the same protection space.  It is recommended</span>
<span class="s1">        that this string be base64 or hexadecimal data.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">algorithm</span> <span class="o">=</span> <span class="n">auth_property</span><span class="p">(</span><span class="s1">&#39;algorithm&#39;</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        A string indicating a pair of algorithms used to produce the digest</span>
<span class="s1">        and a checksum.  If this is not present it is assumed to be &quot;MD5&quot;.</span>
<span class="s1">        If the algorithm is not understood, the challenge should be ignored</span>
<span class="s1">        (and a different one used, if there is more than one).&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="n">qop</span> <span class="o">=</span> <span class="n">_set_property</span><span class="p">(</span><span class="s1">&#39;qop&#39;</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        A set of quality-of-privacy directives such as auth and auth-int.&#39;&#39;&#39;</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">_get_stale</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="n">val</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;stale&#39;</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">val</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">val</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span> <span class="o">==</span> <span class="s1">&#39;true&#39;</span>

    <span class="k">def</span> <span class="nf">_set_stale</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
        <span class="k">if</span> <span class="n">value</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="s1">&#39;stale&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="bp">self</span><span class="p">[</span><span class="s1">&#39;stale&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span> <span class="ow">and</span> <span class="s1">&#39;TRUE&#39;</span> <span class="ow">or</span> <span class="s1">&#39;FALSE&#39;</span>
    <span class="n">stale</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="n">_get_stale</span><span class="p">,</span> <span class="n">_set_stale</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">        A flag, indicating that the previous request from the client was</span>
<span class="s1">        rejected because the nonce value was stale.&#39;&#39;&#39;</span><span class="p">)</span>
    <span class="k">del</span> <span class="n">_get_stale</span><span class="p">,</span> <span class="n">_set_stale</span>

    <span class="c1"># make auth_property a staticmethod so that subclasses of</span>
    <span class="c1"># `WWWAuthenticate` can use it for new properties.</span>
    <span class="n">auth_property</span> <span class="o">=</span> <span class="nb">staticmethod</span><span class="p">(</span><span class="n">auth_property</span><span class="p">)</span>
    <span class="k">del</span> <span class="n">_set_property</span>


<span class="k">class</span> <span class="nc">FileStorage</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;The :class:`FileStorage` class is a thin wrapper over incoming files.</span>
<span class="sd">    It is used by the request object to represent uploaded files.  All the</span>
<span class="sd">    attributes of the wrapper stream are proxied by the file storage so</span>
<span class="sd">    it&#39;s possible to do ``storage.read()`` instead of the long form</span>
<span class="sd">    ``storage.stream.read()``.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">stream</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">filename</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">name</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
                 <span class="n">content_type</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">content_length</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
                 <span class="n">headers</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="n">name</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">stream</span> <span class="o">=</span> <span class="n">stream</span> <span class="ow">or</span> <span class="n">_empty_stream</span>

        <span class="c1"># if no filename is provided we can attempt to get the filename</span>
        <span class="c1"># from the stream object passed.  There we have to be careful to</span>
        <span class="c1"># skip things like &lt;fdopen&gt;, &lt;stderr&gt; etc.  Python marks these</span>
        <span class="c1"># special filenames with angular brackets.</span>
        <span class="k">if</span> <span class="n">filename</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="n">filename</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">stream</span><span class="p">,</span> <span class="s1">&#39;name&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
            <span class="n">s</span> <span class="o">=</span> <span class="n">make_literal_wrapper</span><span class="p">(</span><span class="n">filename</span><span class="p">)</span>
            <span class="k">if</span> <span class="n">filename</span> <span class="ow">and</span> <span class="n">filename</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">==</span> <span class="n">s</span><span class="p">(</span><span class="s1">&#39;&lt;&#39;</span><span class="p">)</span> <span class="ow">and</span> <span class="n">filename</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">==</span> <span class="n">s</span><span class="p">(</span><span class="s1">&#39;&gt;&#39;</span><span class="p">):</span>
                <span class="n">filename</span> <span class="o">=</span> <span class="kc">None</span>

            <span class="c1"># On Python 3 we want to make sure the filename is always unicode.</span>
            <span class="c1"># This might not be if the name attribute is bytes due to the</span>
            <span class="c1"># file being opened from the bytes API.</span>
            <span class="k">if</span> <span class="ow">not</span> <span class="n">PY2</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">filename</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
                <span class="n">filename</span> <span class="o">=</span> <span class="n">filename</span><span class="o">.</span><span class="n">decode</span><span class="p">(</span><span class="n">get_filesystem_encoding</span><span class="p">(),</span>
                                           <span class="s1">&#39;replace&#39;</span><span class="p">)</span>

        <span class="bp">self</span><span class="o">.</span><span class="n">filename</span> <span class="o">=</span> <span class="n">filename</span>
        <span class="k">if</span> <span class="n">headers</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
            <span class="n">headers</span> <span class="o">=</span> <span class="n">Headers</span><span class="p">()</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">headers</span> <span class="o">=</span> <span class="n">headers</span>
        <span class="k">if</span> <span class="n">content_type</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="n">headers</span><span class="p">[</span><span class="s1">&#39;Content-Type&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">content_type</span>
        <span class="k">if</span> <span class="n">content_length</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
            <span class="n">headers</span><span class="p">[</span><span class="s1">&#39;Content-Length&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">content_length</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">_parse_content_type</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="nb">hasattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="s1">&#39;_parsed_content_type&#39;</span><span class="p">):</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">_parsed_content_type</span> <span class="o">=</span> \
                <span class="n">parse_options_header</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">content_type</span><span class="p">)</span>

    <span class="nd">@property</span>
    <span class="k">def</span> <span class="nf">content_type</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;The content-type sent in the header.  Usually not available&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">headers</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;content-type&#39;</span><span class="p">)</span>

    <span class="nd">@property</span>
    <span class="k">def</span> <span class="nf">content_length</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;The content-length sent in the header.  Usually not available&quot;&quot;&quot;</span>
        <span class="k">return</span> <span class="nb">int</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">headers</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;content-length&#39;</span><span class="p">)</span> <span class="ow">or</span> <span class="mi">0</span><span class="p">)</span>

    <span class="nd">@property</span>
    <span class="k">def</span> <span class="nf">mimetype</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Like :attr:`content_type`, but without parameters (eg, without</span>
<span class="sd">        charset, type etc.) and always lowercase.  For example if the content</span>
<span class="sd">        type is ``text/HTML; charset=utf-8`` the mimetype would be</span>
<span class="sd">        ``&#39;text/html&#39;``.</span>

<span class="sd">        .. versionadded:: 0.7</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_parse_content_type</span><span class="p">()</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_parsed_content_type</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span>

    <span class="nd">@property</span>
    <span class="k">def</span> <span class="nf">mimetype_params</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;The mimetype parameters as dict.  For example if the content</span>
<span class="sd">        type is ``text/html; charset=utf-8`` the params would be</span>
<span class="sd">        ``{&#39;charset&#39;: &#39;utf-8&#39;}``.</span>

<span class="sd">        .. versionadded:: 0.7</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">_parse_content_type</span><span class="p">()</span>
        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_parsed_content_type</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>

    <span class="k">def</span> <span class="nf">save</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">dst</span><span class="p">,</span> <span class="n">buffer_size</span><span class="o">=</span><span class="mi">16384</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Save the file to a destination path or file object.  If the</span>
<span class="sd">        destination is a file object you have to close it yourself after the</span>
<span class="sd">        call.  The buffer size is the number of bytes held in memory during</span>
<span class="sd">        the copy process.  It defaults to 16KB.</span>

<span class="sd">        For secure file saving also have a look at :func:`secure_filename`.</span>

<span class="sd">        :param dst: a filename or open file object the uploaded file</span>
<span class="sd">                    is saved to.</span>
<span class="sd">        :param buffer_size: the size of the buffer.  This works the same as</span>
<span class="sd">                            the `length` parameter of</span>
<span class="sd">                            :func:`shutil.copyfileobj`.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="kn">from</span> <span class="nn">shutil</span> <span class="k">import</span> <span class="n">copyfileobj</span>
        <span class="n">close_dst</span> <span class="o">=</span> <span class="kc">False</span>
        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">dst</span><span class="p">,</span> <span class="n">string_types</span><span class="p">):</span>
            <span class="n">dst</span> <span class="o">=</span> <span class="nb">open</span><span class="p">(</span><span class="n">dst</span><span class="p">,</span> <span class="s1">&#39;wb&#39;</span><span class="p">)</span>
            <span class="n">close_dst</span> <span class="o">=</span> <span class="kc">True</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="n">copyfileobj</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">stream</span><span class="p">,</span> <span class="n">dst</span><span class="p">,</span> <span class="n">buffer_size</span><span class="p">)</span>
        <span class="k">finally</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">close_dst</span><span class="p">:</span>
                <span class="n">dst</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>

    <span class="k">def</span> <span class="nf">close</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Close the underlying file if possible.&quot;&quot;&quot;</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">stream</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
        <span class="k">except</span> <span class="ne">Exception</span><span class="p">:</span>
            <span class="k">pass</span>

    <span class="k">def</span> <span class="nf">__nonzero__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">bool</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">filename</span><span class="p">)</span>
    <span class="n">__bool__</span> <span class="o">=</span> <span class="n">__nonzero__</span>

    <span class="k">def</span> <span class="nf">__getattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">getattr</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">stream</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="nb">iter</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">readline</span><span class="p">,</span> <span class="s1">&#39;&#39;</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="k">return</span> <span class="s1">&#39;&lt;</span><span class="si">%s</span><span class="s1">: </span><span class="si">%r</span><span class="s1"> (</span><span class="si">%r</span><span class="s1">)&gt;&#39;</span> <span class="o">%</span> <span class="p">(</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">filename</span><span class="p">,</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">content_type</span>
        <span class="p">)</span>


<span class="c1"># circular dependencies</span>
<span class="kn">from</span> <span class="nn">werkzeug.http</span> <span class="k">import</span> <span class="n">dump_options_header</span><span class="p">,</span> <span class="n">dump_header</span><span class="p">,</span> <span class="n">generate_etag</span><span class="p">,</span> \
    <span class="n">quote_header_value</span><span class="p">,</span> <span class="n">parse_set_header</span><span class="p">,</span> <span class="n">unquote_etag</span><span class="p">,</span> <span class="n">quote_etag</span><span class="p">,</span> \
    <span class="n">parse_options_header</span><span class="p">,</span> <span class="n">http_date</span><span class="p">,</span> <span class="n">is_byte_range_valid</span>
<span class="kn">from</span> <span class="nn">werkzeug</span> <span class="k">import</span> <span class="n">exceptions</span>
</pre></div>

          </div>
        </div>
      </div>
      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
        <div class="sphinxsidebarwrapper"><div class="relations">
<h3>Related Topics</h3>
<ul>
  <li><a href="../../index.html">Documentation overview</a><ul>
  <li><a href="../index.html">Module code</a><ul>
  </ul></li>
  </ul></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
  <h3>Quick search</h3>
    <form class="search" action="../../search.html" method="get">
      <div><input type="text" name="q" /></div>
      <div><input type="submit" value="Go" /></div>
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="footer">
      &copy;2016, Author.
      
      |
      Powered by <a href="http://sphinx-doc.org/">Sphinx 1.4.8</a>
      &amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.9</a>
      
    </div>

    
  </body>
</html>