This file is indexed.

/usr/lib/pyshared/python2.6/pesto-25.egg-info/PKG-INFO is in python-pesto 25-1.

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

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
Metadata-Version: 1.0
Name: pesto
Version: 25
Summary: Library for WSGI applications
Home-page: http://www.ollycope.com/software/pesto
Author: Oliver Cope
Author-email: oliver@redgecko.org
License: BSD
Description: 
        Pesto is a library for Python web applications. Its aim is to make writing WSGI
        web applications easy and fun. Pesto doesn't constrain you -- how you integrate
        with databases, what templating system you use or how you prefer to lay out
        your source files is up to you. Above all, pesto is small, well documented and
        well tested.
        
        Pesto makes it easy to:
        
            - Map any URI to any part of your application.
            - Produce unicode aware, standards compliant WSGI applications.
            - Interrogate WSGI request information -- form variables and HTTP request
              headers.
            - Create and manipulate HTTP headers, redirects, cookies etc.
            - Integrate with any other WSGI application or middleware, giving you
              access to a vast and growing resource.
        
        Development status
        ------------------
        
        Pesto is production ready and used on a wide variety of websites.
        
        To browse or check out the latest development version, visit
        http://patch-tag.com/repo/pesto. For documentation, visit
        http://pesto.redgecko.org/.
        
        Licence
        --------
        
        Pesto is available under the terms of the `new BSD licence
        <http://www.opensource.org/licenses/bsd-license.php>`_.
        
        Documentation
        --------------
        
        Full documentation is included with each release. Documentation for the latest
        version is available at <http://pesto.redgecko.org/>.
        
        
        
        Version 25
        
        * Fixed bug in pesto.utils.MultiDict and added a MultiDict.extend method
        
        Version 24
        
        * Bugfixes for pesto.utils.MultiDict and pesto.dispatch
        
        * pesto.utils.with_request_args decorator handles malformed input more gracefully
        
        Version 23
        
        * Fix for exc_info handling
        
        Version 22
        
        * Partial Python 2.4 backwards compatibility (thanks to Brian Peiris).
        
        * Improvements to the handling of close methods on content iterators
        
        * Other minor bugfixes
        
        Version 21
        
        * HEAD requests are passed to the GET handler if no explicit HEAD handler is
          set up.
        
        * DispatcherApp can now take a ``prefix`` argument that is prepended to all
          match patterns
        
        * Now uses the repoze.lru LRU cache implementation.
        
        Version 20
        
        * Fixed RuntimeError when used under mod_wsgi (thanks to Mateusz Korniak)
        
        * Fixed error parsing information out of user-agent cookie headers (thanks to
          Mateusz Korniak)
        
        Version 19
        
        * pesto.wsgiutils.serve_static_file now correctly sets the Last-Modified
          header (thanks to Samuel Wan)
        
        * Better compliance with HTTP RFC and WSGI spec on 204 No Content and 304 Not
          Modified responses
        
        * Restored Python 2.5 compatibility
        
        Version 18
        
        * PestoWSGIApplication/to_wsgi may now be used to decorate class methods as
          well as regular functions
        
        * Minor bugfixes
        
        Version 17
        
        * pesto.util.MultiDict now retains insertion order of keys. This is useful
          for form processing where you want to know the order in which fields are
          submitted.
        
        * Fixed bugs relating to path handling functions stripping trailing slashes
          eg in ``pesto.wsgiutils.make_absolute_url``. Also
          ``pesto.dispatch.dispatcher_app`` no longer strips trailing slashes either,
          it left to the application to do this if desired.
        
        Version 16
        
        * Fixed error introduced into session handling, where the session cookie was
          not resent if an old session disappeared
        
        Version 15
        
        * Corrected package version number
        
        * Included fixes for session handling (thanks to Ferry Pierre).
        
        Version 14
        
        * FileSessionManager now saves files under dedicated _pesto_sessions
          subdirectory, making it safer to use when initialized on a shared temporary
          directory.
        
        * Corrected pesto.wsgiutils.mount_app, which previously passed a reference to
          an out of date request object to sub apps
        
        * Altered the url() function acquired by dispatcher_app decorated functions
          to allow script_name, netloc and URL scheme to be specified, making it
          possible for multiple Pesto dispatcher_apps mounted at different paths or
          network locations to generate valid URLs for each other.
        
        * pesto.wsgiutils.with_request_args now raises error objects that may be
          more easily separated out from other errors in middleware layers if required.
        
        * Session.save() now forces a save even if no changes have been
          detected (which may happen if you store mutable objects in the session)
        
        * pesto.wsgiutils.with_request_args now raises exceptions generated
          when parsing arguments from request data. This behaviour is generally more
          useful to developers than an error page with no information about what
          parameter is missing.
        
        Version 13
        
        * Added HttpOnly option to cookies
        
        * Session middleware can now have the cookie path and domain overridden
        
        Version 12
        
        * Added a path_info argument to request.make_uri
        
        * Improved support for dispatcher_app to dispatch to bound methods
        
        * Added many missing docstrings and other pylint/cheesecake suggested changes
        
        * Extended request.make_uri to take any query argument that
          wsgiutils.make_query will accept
        
        * make_query now supports taking a list of (name, value) tuples
        
        Version 11
        
        * Removed dbm and rdbms session managers, these were untested, undocumented and
          were not recommended for use.
        
        * Added fix for parse_querystring when qs is empty
        
        * Fixed error on non-UTF8 encoded request body
        
        * Added X-Pesto-Exception header to help debugging of webapps
        
        * Improved dispatch debug logging
        
        * Fixed issue when using dispatcher predicates and caching
        
        * Reversed dispatcher function matching precedence: the first matching function
          wins
        
        * Remove pesto.wsgiutils.MockWSGI and replace with classes in a new
          pesto.testing module
        
        * Added a decorators argument to dispatcher_app.match, allowing handler
          functions to have decorators which are only applied in the context of web
          requests
        
        * Request.cookies is now a MultiDict object with the same API as Request.form,
          Request.files and Request.query
        
        * Renamed urldispatcher to dispatcher_app to clarify intent of this class.
        
        * Made response.Response normalize header case and sort headers on ingress,
          fixing a few consistency issues.
        
        * Adjusted response header handling to be standards compliant on 304 responses
          and ETag headers
        
        * Use wsgiref.validator in MockWSGI
        
        * Refactored some parts of request.py and wsgiutils.py into new httputils.py
          and utils.py modules.
        
        * Removed dependency on stdlib cgi.py (see
          http://mail.python.org/pipermail/web-sig/2009-May/003822.html for reasons).
        
        * Changed variables named 'encoding' to 'charset' to make the naming more
          consistent with HTTP.
        
        * Removed support for Python 2.3. From now on pesto is actively tested on 2.5
          and 2.6, and I will try to support 2.4 if bugs are reported.
        
        
        Version 10
        
        * Fixes in documentation and packaging, but no changes to functionality
        
        
        Version 9
        
        * Added a predicate argument to dispatcher.match, allowing for extra arbitrary
          checks before routing a URL.
        
        * Add basic ETag support
        
        * Removed http exceptions
        
        * Added support for wsigorg.routing_args
        
        * WSGI apps created with pesto now have execution deferred until the first
          iteration. Therefore the iterator's .close method can be used to reliably
          release resources etc.
        
        * Fix for Response objects not catching close methods on upstream content
          iterators
        
        * Added onclose kwarg for Response object. Any functions in onclose will be
          called on the wsgi close event.
        
        * Added request.files object to complement request.form and request.query
        
        * Added MultiDict object to replace FieldStorageWrapper
        
        * Renamed register_pattern to register_converter for consistency
        
        * Allowed multiple close functions to be passed to ClosingIterator
        
        * request.make_uri now uri quotes paths
        
        * Rewrote urldispatcher to use a much more flexible URL matching syntax
        
        * Refactored Request initialisation to ensure that multiple calls don't
          attempt to reinitialize request parameters
        
        * added Response.getheaders, Response.getheader and Response.from_wsgi
        
        * add an ExtensiblePattern to dispatcher and enable it by default
        
        * Changed dispatcher to be a WSGI callable
        
        * Added wsgiutils.ClosingIterator and wsgiutils.overlay
        
        * Pesto response objects are now valid WSGI apps
        
        * Ensure the same Request instance is returned when called multiple times on
          the same environ object
        
        * Added a function for mapping request form parameters to function arguments
        
        * Updated documentation: now requires sphinx for building docs
        
        * Renamed WSGIRequest to Request for consistency with Response
        
        * Changed 'despatcher' to 'dispatcher' throughout, after it was pointed out
          that no one spells it this way any more
        
        
        Version 8
        
        * Merged pesto.utils with pesto.wsgiutils
        
        * Refactored builtin static server to allow it to be used to serve ad-hoc
          single files
        
        * Added a make_query utility function to wsgiutils
        
        * Fixed request.make_uri when presented with a relative URI. expanded the
          docstring and tests.
        
        * Static server fixes for windows environments
        
        
        Version 7
        
        * Reimplemented session saving machinery using the WSGI standard close()
          mechanism.
        
        * Request.FieldStorageWrapper now raises a KeyError on non-existant item access
        
        
        Version 6
        
        * Added uri_join and fixed request.make_uri path concatenation logic
        
        * Moved debug param out of despatch class and into despatcher_app, where it can
          be applied across all despatchers in operation
        
        * Removed duplicate default charset/encoding setting
        
        * Added Response.bad_request() classmethod
        
        * Added Response.buffered method
        
        * Added Response.add_cookie
        
        
        Version 5
        
        * Changed wsgiutils.make_absolute_url to bring into line with PEP 333 and
          improve handling of relative URIs
        
        * Added Response.redirect, Response.not_found etc classmethods, replacing
          previous freestanding functions
        
        * make_query now allows a separator character to be specified
        
        * pesto.currentrequest() returns None when no request available
        
        * Add WSGIRequest.query to model querystring data. Both WSGIRequest.form and
          .query are now properties and lazily instantiated.
        
        
        Version 4
        
        * First publicly released version! 
        
        
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
Classifier: Topic :: Software Development :: Libraries :: Python Modules