diff options
| -rw-r--r-- | Doc/library/cgi.rst | 35 | ||||
| -rwxr-xr-x | Lib/cgi.py | 124 | ||||
| -rw-r--r-- | Lib/test/test_cgi.py | 42 |
3 files changed, 11 insertions, 190 deletions
diff --git a/Doc/library/cgi.rst b/Doc/library/cgi.rst index 9f0171c..0a9ccd3 100644 --- a/Doc/library/cgi.rst +++ b/Doc/library/cgi.rst @@ -63,9 +63,7 @@ prints a simple piece of HTML:: Using the cgi module -------------------- -Begin by writing ``import cgi``. Do not use ``from cgi import *`` --- the -module defines all sorts of names for its own use or for backward compatibility -that you don't want in your namespace. +Begin by writing ``import cgi``. When you write a new script, consider adding the line:: @@ -83,12 +81,11 @@ produced by :mod:`cgitb` provide information that can save you a lot of time in tracking down bugs. You can always remove the ``cgitb`` line later when you have tested your script and are confident that it works correctly. -To get at submitted form data, it's best to use the :class:`FieldStorage` class. -The other classes defined in this module are provided mostly for backward -compatibility. Instantiate it exactly once, without arguments. This reads the -form contents from standard input or the environment (depending on the value of -various environment variables set according to the CGI standard). Since it may -consume standard input, it should be instantiated only once. +To get at submitted form data, use the :class:`FieldStorage` class. Instantiate +it exactly once, without arguments. This reads the form contents from standard +input or the environment (depending on the value of various environment +variables set according to the CGI standard). Since it may consume standard +input, it should be instantiated only once. The :class:`FieldStorage` instance can be indexed like a Python dictionary, and also supports the standard dictionary methods :meth:`__contains__` and @@ -245,26 +242,6 @@ Using these methods you can write nice compact code:: do_something(item) -Old classes ------------ - -These classes, present in earlier versions of the :mod:`cgi` module, are still -supported for backward compatibility. New applications should use the -:class:`FieldStorage` class. - -:class:`SvFormContentDict` stores single value form content as dictionary; it -assumes each field name occurs in the form only once. - -:class:`FormContentDict` stores multiple value form content as a dictionary (the -form items are lists of values). Useful if your form contains multiple fields -with the same name. - -Other classes (:class:`FormContent`, :class:`InterpFormContentDict`) are present -for backwards compatibility with really old applications only. If you still use -these and would be inconvenienced when they disappeared from a next version of -this module, drop me a note. - - .. _functions-in-cgi-module: Functions @@ -15,9 +15,6 @@ This module defines a number of utilities for use by CGI scripts written in Python. """ -# XXX Perhaps there should be a slimmed version that doesn't contain -# all those backwards compatible and debugging classes and functions? - # History # ------- # @@ -43,8 +40,7 @@ import rfc822 import collections from io import StringIO -__all__ = ["MiniFieldStorage", "FieldStorage", "FormContentDict", - "SvFormContentDict", "InterpFormContentDict", "FormContent", +__all__ = ["MiniFieldStorage", "FieldStorage", "parse", "parse_qs", "parse_qsl", "parse_multipart", "parse_header", "print_exception", "print_environ", "print_form", "print_directory", "print_arguments", @@ -777,124 +773,6 @@ class FieldStorage: return tempfile.TemporaryFile("w+", encoding="utf-8", newline="\n") - -# Backwards Compatibility Classes -# =============================== - -class FormContentDict(collections.Mapping): - """Form content as dictionary with a list of values per field. - - form = FormContentDict() - - form[key] -> [value, value, ...] - key in form -> Boolean - form.keys() -> [key, key, ...] - form.values() -> [[val, val, ...], [val, val, ...], ...] - form.items() -> [(key, [val, val, ...]), (key, [val, val, ...]), ...] - form.dict == {key: [val, val, ...], ...} - - """ - def __init__(self, environ=os.environ, keep_blank_values=0, strict_parsing=0): - self.dict = self.data = parse(environ=environ, - keep_blank_values=keep_blank_values, - strict_parsing=strict_parsing) - self.query_string = environ['QUERY_STRING'] - - def __len__(self): - return len(self.dict) - - def __iter__(self): - return iter(self.dict) - - def __getitem__(self, key): - return self.dict[key] - - -class SvFormContentDict(FormContentDict): - """Form content as dictionary expecting a single value per field. - - If you only expect a single value for each field, then form[key] - will return that single value. It will raise an IndexError if - that expectation is not true. If you expect a field to have - possible multiple values, than you can use form.getlist(key) to - get all of the values. values() and items() are a compromise: - they return single strings where there is a single value, and - lists of strings otherwise. - - """ - def __getitem__(self, key): - if len(self.dict[key]) > 1: - raise IndexError('expecting a single value') - return self.dict[key][0] - def getlist(self, key): - return self.dict[key] - def values(self): - result = [] - for value in self.dict.values(): - if len(value) == 1: - result.append(value[0]) - else: result.append(value) - return result - def items(self): - result = [] - for key, value in self.dict.items(): - if len(value) == 1: - result.append((key, value[0])) - else: result.append((key, value)) - return result - - -class InterpFormContentDict(SvFormContentDict): - """This class is present for backwards compatibility only.""" - def __getitem__(self, key): - v = SvFormContentDict.__getitem__(self, key) - if v[0] in '0123456789+-.': - try: return int(v) - except ValueError: - try: return float(v) - except ValueError: pass - return v.strip() - def values(self): - result = [] - for key in self.keys(): - try: - result.append(self[key]) - except IndexError: - result.append(self.dict[key]) - return result - def items(self): - result = [] - for key in self.keys(): - try: - result.append((key, self[key])) - except IndexError: - result.append((key, self.dict[key])) - return result - - -class FormContent(FormContentDict): - """This class is present for backwards compatibility only.""" - def values(self, key): - if key in self.dict :return self.dict[key] - else: return None - def indexed_value(self, key, location): - if key in self.dict: - if len(self.dict[key]) > location: - return self.dict[key][location] - else: return None - else: return None - def value(self, key): - if key in self.dict: return self.dict[key][0] - else: return None - def length(self, key): - return len(self.dict[key]) - def stripped(self, key): - if key in self.dict: return self.dict[key][0].strip() - else: return None - def pars(self): - return self.dict - - # Test/debug code # =============== diff --git a/Lib/test/test_cgi.py b/Lib/test/test_cgi.py index b1102cf..f28719b 100644 --- a/Lib/test/test_cgi.py +++ b/Lib/test/test_cgi.py @@ -143,56 +143,22 @@ class CgiTests(unittest.TestCase): self.assertEqual(d, expect, "Error parsing %s" % repr(orig)) env = {'QUERY_STRING': orig} - fcd = cgi.FormContentDict(env) - sd = cgi.SvFormContentDict(env) fs = cgi.FieldStorage(environ=env) if type(expect) == type({}): # test dict interface - self.assertEqual(len(expect), len(fcd)) - self.assertEqual(norm(expect.keys()), norm(fcd.keys())) - self.assertEqual(norm(expect.values()), norm(fcd.values())) - self.assertEqual(norm(expect.items()), norm(fcd.items())) - self.assertEqual(fcd.get("nonexistent field", "default"), "default") - self.assertEqual(len(sd), len(fs)) - self.assertEqual(norm(sd.keys()), norm(fs.keys())) + self.assertEqual(len(expect), len(fs)) + self.assertEqual(norm(expect.keys()), norm(fs.keys())) + ##self.assertEqual(norm(expect.values()), norm(fs.values())) + ##self.assertEqual(norm(expect.items()), norm(fs.items())) self.assertEqual(fs.getvalue("nonexistent field", "default"), "default") # test individual fields for key in expect.keys(): expect_val = expect[key] - self.assert_(key in fcd) - self.assertEqual(norm(fcd[key]), norm(expect[key])) - self.assertEqual(fcd.get(key, "default"), fcd[key]) self.assert_(key in fs) if len(expect_val) > 1: - single_value = 0 - else: - single_value = 1 - try: - val = sd[key] - except IndexError: - self.failIf(single_value) self.assertEqual(fs.getvalue(key), expect_val) else: - self.assert_(single_value) - self.assertEqual(val, expect_val[0]) self.assertEqual(fs.getvalue(key), expect_val[0]) - self.assertEqual(norm(sd.getlist(key)), norm(expect_val)) - if single_value: - self.assertEqual(norm(sd.values()), - first_elts(norm(expect.values()))) - self.assertEqual(norm(sd.items()), - first_second_elts(norm(expect.items()))) - - def test_weird_formcontentdict(self): - # Test the weird FormContentDict classes - env = {'QUERY_STRING': "x=1&y=2.0&z=2-3.%2b0&1=1abc"} - expect = {'x': 1, 'y': 2.0, 'z': '2-3.+0', '1': '1abc'} - d = cgi.InterpFormContentDict(env) - for k, v in expect.items(): - self.assertEqual(d[k], v) - for k, v in d.items(): - self.assertEqual(expect[k], v) - self.assertEqual(norm(expect.values()), norm(d.values())) def test_log(self): cgi.log("Testing") |