790 """ - 791 Represents a <form> element. - 792 """ - 793 -

794 - def inputs(self): -

795 """ - 796 Returns an accessor for all the input elements in the form. - 797 - 798 See `InputGetter` for more information about the object. - 799 """ - 800 return InputGetter(self) -

801 inputs = property(inputs, doc=inputs. 788 # form handling + 789 ################################################################################ + 790 + 791 -class FormElement(HtmlElement): + 792 """ + 793 Represents a <form> element. + 794 """ + 795 + 796 - def inputs(self): + 797 """ + 798 Returns an accessor for all the input elements in the form. + 799 + 800 See `InputGetter` for more information about the object. + 801 """ + 802 return InputGetter(self) + 803 inputs = property(inputs, doc=inputs.__doc__) - 802 - 803 - def _fields__get(self): - 804 """ - 805 Dictionary-like object that represents all the fields in this - 806 form. You can set values in this dictionary to effect the - 807 form. - 808 """ - 809 return FieldsDict(self.inputs) - 810 - def _fields__set(self, value): - 811 prev_keys = self.fields. 804 + 805 - def _fields__get(self): + 806 """ + 807 Dictionary-like object that represents all the fields in this + 808 form. You can set values in this dictionary to effect the + 809 form. + 810 """ + 811 return FieldsDict(self.inputs) + 812 - def _fields__set(self, value): + 813 prev_keys = self.fields.keys() - 812 for key, 814 for key, value.items(): - 813 if key in prev_keys: - 814 prev_keys. 815 if key in prev_keys: + 816 prev_keys.remove(key) - 815 self.fields[key] = 817 self.fields[key] = value - 816 for key in prev_keys: - 817 if key is None: - 818 # Case of an unnamed input; these aren't really - 819 # expressed in form_values() anyway. - 820 continue - 821 self.fields[key] = None - 822 - 823 fields = property(_fields__get, _fields__set, doc=_fields__get. 818 for key in prev_keys: + 819 if key is None: + 820 # Case of an unnamed input; these aren't really + 821 # expressed in form_values() anyway. + 822 continue + 823 self.fields[key] = None + 824 + 825 fields = property(_fields__get, _fields__set, doc=_fields__get.__doc__) - 824 - 825 - def _name(self): - 826 if self. 826 + 827 - def _name(self): + 828 if self.get('name'): - 827 return self. 829 return self.get('name') - 828 elif self. 830 elif self.get('id'): - 829 return '#' + self. 831 return '#' + self.get('id') - 830 832 forms = list(self.body.iter('form')) - 831 if not 833 if not forms: - 832 834 forms = list(self.body.iter('{%s}form' % XHTML_NAMESPACE)) - 833 return str( 835 return str(forms.index(self)) - 834 - 835 - def form_values(self): - 836 """ - 837 Return a list of tuples of the field values for the form. - 838 This is suitable to be passed to ``urllib.urlencode()``. - 839 """ - 840 results = [] - 841 for el in self.inputs: - 842 836 + 837 - def form_values(self): + 838 """ + 839 Return a list of tuples of the field values for the form. + 840 This is suitable to be passed to ``urllib.urlencode()``. + 841 """ + 842 results = [] + 843 for el in self.inputs: + 844 name = el.name - 843 if not 845 if not name: - 844 continue - 845 846 continue + 847 tag) - 846 if 848 if tag == 'textarea': - 847 results.append(( 849 results.append((name, el.value)) - 848 elif 850 elif tag == 'select': - 849 851 value - 850 if el.multiple: - 851 for v in 852 if el.multiple: + 853 for v in value: - 852 results.append(( 854 results.append((name, v)) - 853 elif 855 elif value is not None: - 854 results.append(( 856 results.append((name, el.value)) - 855 else: - 856 assert 857 else: + 858 assert tag == 'input', ( - 857 "Unexpected tag: %r" % el) - 858 if el.checkable and not el.checked: - 859 continue - 860 if el.type in ('submit', 'image', 'reset'): + 859 "Unexpected tag: %r" % el) + 860 if el.checkable and not el.checked: 861 continue - 862 862 if el.type in ('submit', 'image', 'reset'): + 863 continue + 864 value - 863 if 865 if value is not None: - 864 results.append(( 866 results.append((name, el.value)) - 865 return results - 866 - 867 - def _action__get(self): - 868 """ - 869 Get/set the form's ``action`` attribute. - 870 """ - 871 base_url = self.base_url - 872 action = self. 867 return results + 868 + 869 - def _action__get(self): + 870 """ + 871 Get/set the form's ``action`` attribute. + 872 """ + 873 base_url = self.base_url + 874 action = self.get('action') - 873 if base_url and action is not None: - 874 return urljoin(base_url, action) - 875 else: - 876 return action - 877 - def _action__set(self, value): - 878 self. 875 if base_url and action is not None: + 876 return urljoin(base_url, action) + 877 else: + 878 return action + 879 - def _action__set(self, value): + 880 self.set('action', value) - 879 - def _action__del(self): - 880 if 'action' in self. 881 - def _action__del(self): + 882 if 'action' in self.attrib: - 881 del self. 883 del self.attrib['action'] - 882 action = property(_action__get, _action__set, _action__del, doc=_action__get. 884 action = property(_action__get, _action__set, _action__del, doc=_action__get.__doc__) - 883 - 884 - def _method__get(self): - 885 """ - 886 Get/set the form's method. Always returns a capitalized - 887 string, and defaults to ``'GET'`` - 888 """ - 889 return self. 885 + 886 - def _method__get(self): + 887 """ + 888 Get/set the form's method. Always returns a capitalized + 889 string, and defaults to ``'GET'`` + 890 """ + 891 return self.get('method', 'GET').upper() - 890 - def _method__set(self, value): - 891 self. 892 - def _method__set(self, value): + 893 self.set('method', value.upper()) - 892 method = property(_method__get, _method__set, doc=_method__get. 894 method = property(_method__get, _method__set, doc=_method__get.__doc__) - 893 - 894 HtmlElementClassLookup._default_element_classes['form'] = FormElement - 895 - 896 -def submit_form(form, extra_values=None, open_http=None): - 897 """ - 898 Helper function to submit a form. Returns a file-like object, as from - 899 ``urllib.urlopen()``. This object also has a ``.geturl()`` function, - 900 which shows the URL if there were any redirects. - 901 - 902 You can use this like:: + 895 + 896 HtmlElementClassLookup._default_element_classes['form'] = FormElement + 897 + 898 -def submit_form(form, extra_values=None, open_http=None): + 899 """ + 900 Helper function to submit a form. Returns a file-like object, as from + 901 ``urllib.urlopen()``. This object also has a ``.geturl()`` function, + 902 which shows the URL if there were any redirects. 903 - 904 form = doc.forms[0] - 905 form.inputs['foo'].value = 'bar' # etc - 906 response = form.submit() - 907 doc = parse(response) - 908 doc.make_links_absolute(response.geturl()) - 909 - 910 To change the HTTP requester, pass a function as ``open_http`` keyword - 911 argument that opens the URL for you. The function must have the following - 912 signature:: - 913 - 914 open_http(method, URL, values) + 904 You can use this like:: + 905 + 906 form = doc.forms[0] + 907 form.inputs['foo'].value = 'bar' # etc + 908 response = form.submit() + 909 doc = parse(response) + 910 doc.make_links_absolute(response.geturl()) + 911 + 912 To change the HTTP requester, pass a function as ``open_http`` keyword + 913 argument that opens the URL for you. The function must have the following + 914 signature:: 915 - 916 The action is one of 'GET' or 'POST', the URL is the target URL as a - 917 string, and the values are a sequence of ``(name, value)`` tuples with the - 918 form data. - 919 """ - 920 916 open_http(method, URL, values) + 917 + 918 The action is one of 'GET' or 'POST', the URL is the target URL as a + 919 string, and the values are a sequence of ``(name, value)`` tuples with the + 920 form data. + 921 """ + 922 values = form.form_values() - 921 if extra_values: - 922 if hasattr(extra_values, 'items'): - 923 extra_values = extra_values. 923 if extra_values: + 924 if hasattr(extra_values, 'items'): + 925 extra_values = extra_values.items() - 924 926 values.extend(extra_values) - 925 if open_http is None: - 926 open_http = open_http_urllib - 927 if form.action: - 928 url = form.action - 929 else: - 930 url = form.base_url - 931 return open_http(form.method, url, 927 if open_http is None: + 928 open_http = open_http_urllib + 929 if form.action: + 930 url = form.action + 931 else: + 932 url = form.base_url + 933 return open_http(form.method, url, values) - 932 - 933 -def open_http_urllib(method, url, values): - 934 if not url: - 935 raise ValueError("cannot submit, no URL provided") - 936 ## FIXME: should test that it's not a relative URL or something - 937 try: - 938 from urllib import urlencode, urlopen - 939 except ImportError: # Python 3 - 940 from urllib.request import urlopen - 941 from urllib. 934 + 935 -def open_http_urllib(method, url, values): + 936 if not url: + 937 raise ValueError("cannot submit, no URL provided") + 938 ## FIXME: should test that it's not a relative URL or something + 939 try: + 940 from urllib import urlencode, urlopen + 941 except ImportError: # Python 3 + 942 from urllib.request import urlopen + 943 from urllib.parse import urlencode - 942 if method == 'GET': - 943 if '?' in url: - 944 url += '&' - 945 else: - 946 url += '?' - 947 url += urlencode( 944 if method == 'GET': + 945 if '?' in url: + 946 url += '&' + 947 else: + 948 url += '?' + 949 url += urlencode(values) - 948 data = None - 949 else: - 950 data = urlencode( 950 data = None + 951 else: + 952 data = urlencode(values) - 951 return urlopen(url, data) - 952 - 953 -class FieldsDict(DictMixin): - 954 - 955 - def __init__(self, inputs): - 956 self.inputs = inputs - 957 - def __getitem__(self, item): - 958 return self.inputs[item]. 953 return urlopen(url, data) + 954 + 955 -class FieldsDict(DictMixin): + 956 + 957 - def __init__(self, inputs): + 958 self.inputs = inputs + 959 - def __getitem__(self, item): + 960 return self.inputs[item].value - 959 - def __setitem__(self, item, value): - 960 self.inputs[item]. 961 - def __setitem__(self, item, value): + 962 self.inputs[item].value - 961 - def __delitem__(self, item): - 962 raise KeyError( - 963 "You cannot remove keys from ElementDict") - 964 - def keys(self): - 965 return self.inputs. 963 - def __delitem__(self, item): + 964 raise KeyError( + 965 "You cannot remove keys from ElementDict") + 966 - def keys(self): + 967 return self.inputs.keys() - 966 - def __contains__(self, item): - 967 return item in self.inputs - 968 - def __iter__(self): - 969 return 968 - def __contains__(self, item): + 969 return item in self.inputs + 970 - def __iter__(self): + 971 return iter(self.inputs.keys()) - 970 - def __len__(self): - 971 return len(self.inputs) - 972 - 973 - def __repr__(self): - 974 return '<%s for form %s>' % ( - 975 self.__class__.__name__, - 976 self.inputs.form._name()) - 977 - 978 -class InputGetter(object): - 979 - 980 """ - 981 An accessor that represents all the input fields in a form. - 982 - 983 You can get fields by name from this, with - 984 ``form.inputs['field_name']``. If there are a set of checkboxes - 985 with the same name, they are returned as a list (a `CheckboxGroup` - 986 which also allows value setting). Radio inputs are handled - 987 similarly. - 988 - 989 You can also iterate over this to get all input elements. This - 990 won't return the same thing as if you get all the names, as - 991 checkboxes and radio elements are returned individually. - 992 """ - 993 - 994 972 - def __len__(self): + 973 return len(self.inputs) + 974 + 975 - def __repr__(self): + 976 return '<%s for form %s>' % ( + 977 self.__class__.__name__, + 978 self.inputs.form._name()) + 979 + 980 -class InputGetter(object): + 981 + 982 """ + 983 An accessor that represents all the input fields in a form. + 984 + 985 You can get fields by name from this, with + 986 ``form.inputs['field_name']``. If there are a set of checkboxes + 987 with the same name, they are returned as a list (a `CheckboxGroup` + 988 which also allows value setting). Radio inputs are handled + 989 similarly. + 990 + 991 You can also iterate over this to get all input elements. This + 992 won't return the same thing as if you get all the names, as + 993 checkboxes and radio elements are returned individually. + 994 """ + 995 + 996 _name_xpath = etree.XPath(".//*[@name = $name and (local-name(.) = 'select' or local-name(.) = 'input' or local-name(.) = 'textarea')]") - 995 _all_xpath = 997 _all_xpath = etree.XPath(".//*[local-name() = 'select' or local-name() = 'input' or local-name() = 'textarea']") - 996 - 997 - def __init__(self, form): - 998 self.form = form - 999 -1000 - def __repr__(self): - 1001 return '<%s for form %s>' % ( -1002 self.__class__.__name__, -1003 self.form._name()) - 1004 -1005 ## FIXME: there should be more methods, and it's unclear if this is -1006 ## a dictionary-like object or list-like object -1007 -1008 - def __getitem__(self, name): - 1009 results = self. 998 + 999 - def __init__(self, form): + 1000 self.form = form + 1001 +1002 - def __repr__(self): + 1003 return '<%s for form %s>' % ( +1004 self.__class__.__name__, +1005 self.form._name()) + 1006 +1007 ## FIXME: there should be more methods, and it's unclear if this is +1008 ## a dictionary-like object or list-like object +1009 +1010 - def __getitem__(self, name): + 1011 results = self._name_xpath(self.form, name) -1010 if results: -1011 1012 if results: +1013 type = results[0].get('type') -1012 if 1014 if type == 'radio' and len(results) > 1: -1013 group = RadioGroup(results) -1014 group.1015 group = RadioGroup(results) +1016 group.name = name -1015 return group -1016 elif 1017 return group +1018 elif type == 'checkbox' and len(results) > 1: -1017 group = CheckboxGroup(results) -1018 group.1019 group = CheckboxGroup(results) +1020 group.name = name -1019 return group -1020 else: -1021 # I don't like throwing away elements like this -1022 return results[0] -1023 else: -1024 raise KeyError( -1025 "No input element with the name %r" % 1021 return group +1022 else: +1023 # I don't like throwing away elements like this +1024 return results[0] +1025 else: +1026 raise KeyError( +1027 "No input element with the name %r" % name) - 1026 -1027 - def __contains__(self, name): - 1028 results = self.1028 +1029 - def __contains__(self, name): + 1030 results = self._name_xpath(self.form, name) -1029 return bool(results) - 1030 -1031 - def keys(self): - 1032 names = 1031 return bool(results) + 1032 +1033 - def keys(self): + 1034 names = set() -1033 for el in self: -1034 names.1035 for el in self: +1036 names.add(el.name) -1035 if None in names: -1036 names.1037 if None in names: +1038 names.remove(None) -1037 return list(names) - 1038 -1039 - def __iter__(self): - 1040 ## FIXME: kind of dumb to turn a list into an iterator, only -1041 ## to have it likely turned back into a list again :( -1042 return 1039 return list(names) + 1040 +1041 - def __iter__(self): + 1042 ## FIXME: kind of dumb to turn a list into an iterator, only +1043 ## to have it likely turned back into a list again :( +1044 return iter(self._all_xpath(self.form)) - 1043 -1044 -class InputMixin(object): - 1045 -1046 """ -1047 Mix-in for all input elements (input, select, and textarea) -1048 """ -1049 -1050 -1051 - def _name__get(self): - 1052 """ -1053 Get/set the name of the element -1054 """ -1055 return self.1045 +1046 -class InputMixin(object): + 1047 +1048 """ +1049 Mix-in for all input elements (input, select, and textarea) +1050 """ +1051 +1052 +1053 - def _name__get(self): + 1054 """ +1055 Get/set the name of the element +1056 """ +1057 return self.get('name') - 1056 - def _name__set(self, value): - 1057 self.1058 - def _name__set(self, value): + 1059 self.set('name', value) - 1058 - def _name__del(self): - 1059 if 'name' in self.1060 - def _name__del(self): + 1061 if 'name' in self.attrib: -1060 del self.1062 del self.attrib['name'] - 1061 1063 name = property(_name__get, _name__set, _name__del, doc=_name__get.__doc__) -1062 -1063 - def __repr__(self): - 1064 1064 +1065 - def __repr__(self): + 1066 type = getattr(self, 'type', None) -1065 if 1067 if type: -1066 1068 type = ' type=%r' % type -1067 else: -1068 1069 else: +1070 type = '' -1069 return '<%s %x name=%r%s>' % ( -1070 self.__class__.__name__, id(self), self.1071 return '<%s %x name=%r%s>' % ( +1072 self.__class__.__name__, id(self), self.name, type) - 1071 -1072 -class TextareaElement(InputMixin, HtmlElement): - 1073 """ -1074 ``<textarea>`` element. You can get the name with ``.name`` and -1075 get/set the value with ``.value`` -1076 """ -1077 -1078 - def _value__get(self): - 1079 """ -1080 Get/set the value (which is the contents of this element) -1081 """ -1082 content = self.1073 +1074 -class TextareaElement(InputMixin, HtmlElement): + 1075 """ +1076 ``<textarea>`` element. You can get the name with ``.name`` and +1077 get/set the value with ``.value`` +1078 """ +1079 +1080 - def _value__get(self): + 1081 """ +1082 Get/set the value (which is the contents of this element) +1083 """ +1084 content = self.text or '' -1083 if self.1085 if self.tag.startswith("{%s}" % XHTML_NAMESPACE): -1084 serialisation_method = 'xml' -1085 else: -1086 serialisation_method = 'html' -1087 for el in self: -1088 # it's rare that we actually get here, so let's not use ''.join() -1089 content += 1086 serialisation_method = 'xml' +1087 else: +1088 serialisation_method = 'html' +1089 for el in self: +1090 # it's rare that we actually get here, so let's not use ''.join() +1091 content += etree.tostring( -1090 el, method=serialisation_method, encoding='unicode') -1091 return content - 1092 - def _value__set(self, value): - 1093 del self[:] -1094 self.1092 el, method=serialisation_method, encoding='unicode') +1093 return content + 1094 - def _value__set(self, value): + 1095 del self[:] +1096 self.value - 1095 - def _value__del(self): - 1096 self.1097 - def _value__del(self): + 1098 self.text = '' -1097 del self[:] - 1098 1099 del self[:] + 1100 _value__get.__doc__) - 1099 -1100 HtmlElementClassLookup._default_element_classes['textarea'] = TextareaElement -1101 -1102 -class SelectElement(InputMixin, HtmlElement): - 1103 """ -1104 ``<select>`` element. You can get the name with ``.name``. -1105 -1106 ``.value`` will be the value of the selected option, unless this -1107 is a multi-select element (``<select multiple>``), in which case -1108 it will be a set-like object. In either case ``.value_options`` -1109 gives the possible values. -1110 -1111 The boolean attribute ``.multiple`` shows if this is a -1112 multi-select. -1113 """ -1114 -1115 - def _value__get(self): - 1116 """ -1117 Get/set the value of this select (the selected option). -1118 -1119 If this is a multi-select, this is a set-like object that -1120 represents all the selected options. -1121 """ -1122 if self.multiple: -1123 return MultipleSelectOptions(self) -1124 for el in _options_xpath(self): -1125 if el.1101 +1102 HtmlElementClassLookup._default_element_classes['textarea'] = TextareaElement +1103 +1104 -class SelectElement(InputMixin, HtmlElement): + 1105 """ +1106 ``<select>`` element. You can get the name with ``.name``. +1107 +1108 ``.value`` will be the value of the selected option, unless this +1109 is a multi-select element (``<select multiple>``), in which case +1110 it will be a set-like object. In either case ``.value_options`` +1111 gives the possible values. +1112 +1113 The boolean attribute ``.multiple`` shows if this is a +1114 multi-select. +1115 """ +1116 +1117 - def _value__get(self): + 1118 """ +1119 Get/set the value of this select (the selected option). +1120 +1121 If this is a multi-select, this is a set-like object that +1122 represents all the selected options. +1123 """ +1124 if self.multiple: +1125 return MultipleSelectOptions(self) +1126 for el in _options_xpath(self): +1127 if el.get('selected') is not None: -1126 1128 get('value') -1127 if 1129 if value is None: -1128 1130 text or '' -1129 if 1131 if value: -1130 1132 value.strip() -1131 return 1133 return value -1132 return None - 1133 -1134 - def _value__set(self, value): - 1135 if self.multiple: -1136 if isinstance(1134 return None + 1135 +1136 - def _value__set(self, value): + 1137 if self.multiple: +1138 if isinstance(value, basestring): -1137 raise TypeError( -1138 "You must pass in a sequence") -1139 self.1139 raise TypeError( +1140 "You must pass in a sequence") +1141 self.value.clear() -1140 self.1142 self.value) -1141 return -1142 if 1143 return +1144 if value is not None: -1143 1145 value.strip() -1144 for el in _options_xpath(self): -1145 opt_value = el.1146 for el in _options_xpath(self): +1147 opt_value = el.get('value') -1146 if opt_value is None: -1147 opt_value = el.1148 if opt_value is None: +1149 opt_value = el.text or '' -1148 if opt_value: -1149 opt_value = opt_value.strip() -1150 if opt_value == 1150 if opt_value: +1151 opt_value = opt_value.strip() +1152 if opt_value == value: -1151 checked_option = el -1152 break -1153 else: -1154 raise ValueError( -1155 "There is no option with the value of %r" % 1153 checked_option = el +1154 break +1155 else: +1156 raise ValueError( +1157 "There is no option with the value of %r" % value) -1156 for el in _options_xpath(self): -1157 if 'selected' in el.1158 for el in _options_xpath(self): +1159 if 'selected' in el.attrib: -1158 del el.1160 del el.attrib['selected'] -1159 if 1161 if value is not None: -1160 checked_option.1162 checked_option.set('selected', '') - 1161 -1162 - def _value__del(self): - 1163 # FIXME: should del be allowed at all? -1164 if self.multiple: -1165 self.1163 +1164 - def _value__del(self): + 1165 # FIXME: should del be allowed at all? +1166 if self.multiple: +1167 self.value.clear() -1166 else: -1167 self.1168 else: +1169 self.value = None - 1168 -1169 1170 +1171 _value__get.__doc__) -1170 -1171 - def value_options(self): - 1172 """ -1173 All the possible values this select can have (the ``value`` -1174 attribute of all the ``<option>`` elements. -1175 """ -1176 1172 +1173 - def value_options(self): + 1174 """ +1175 All the possible values this select can have (the ``value`` +1176 attribute of all the ``<option>`` elements. +1177 """ +1178 options = [] -1177 for el in _options_xpath(self): -1178 1179 for el in _options_xpath(self): +1180 get('value') -1179 if 1181 if value is None: -1180 1182 text or '' -1181 if 1183 if value: -1182 1184 value.strip() -1183 1185 options.append(value) -1184 return 1186 return options - 1185 1187 value_options = property(value_options.__doc__) -1186 -1187 - def _multiple__get(self): - 1188 """ -1189 Boolean attribute: is there a ``multiple`` attribute on this element. -1190 """ -1191 return 'multiple' in self.1188 +1189 - def _multiple__get(self): + 1190 """ +1191 Boolean attribute: is there a ``multiple`` attribute on this element. +1192 """ +1193 return 'multiple' in self.attrib - 1192 - def _multiple__set(self, value): - 1193 if 1194 - def _multiple__set(self, value): + 1195 if value: -1194 self.1196 self.set('multiple', '') -1195 elif 'multiple' in self.1197 elif 'multiple' in self.attrib: -1196 del self.1198 del self.attrib['multiple'] - 1197 multiple = property(_multiple__get, _multiple__set, doc=_multiple__get.1199 multiple = property(_multiple__get, _multiple__set, doc=_multiple__get.__doc__) - 1198 -1199 HtmlElementClassLookup._default_element_classes['select'] = SelectElement -1200 -1201 -class MultipleSelectOptions(SetMixin): - 1202 """ -1203 Represents all the selected options in a ``<select multiple>`` element. -1204 -1205 You can add to this set-like option to select an option, or remove -1206 to unselect the option. -1207 """ -1208 -1209 - def __init__(self, select): - 1210 self.select = select - 1211 -1212 - def options(self): - 1213 """ -1214 Iterator of all the ``<option>`` elements. -1215 """ -1216 return 1200 +1201 HtmlElementClassLookup._default_element_classes['select'] = SelectElement +1202 +1203 -class MultipleSelectOptions(SetMixin): + 1204 """ +1205 Represents all the selected options in a ``<select multiple>`` element. +1206 +1207 You can add to this set-like option to select an option, or remove +1208 to unselect the option. +1209 """ +1210 +1211 - def __init__(self, select): + 1212 self.select = select + 1213 +1214 - def options(self): + 1215 """ +1216 Iterator of all the ``<option>`` elements. +1217 """ +1218 return iter(_options_xpath(self.select)) - 1217 1219 options = property(options) -1218 -1219 - def __iter__(self): - 1220 for option in self.1220 +1221 - def __iter__(self): + 1222 for option in self.options: -1221 if 'selected' in option.1223 if 'selected' in option.attrib: -1222 opt_value = option.1224 opt_value = option.get('value') -1223 if opt_value is None: -1224 opt_value = option.1225 if opt_value is None: +1226 opt_value = option.text or '' -1225 if opt_value: -1226 opt_value = opt_value.strip() -1227 yield opt_value - 1228 -1229 - def add(self, item): - 1230 for option in self.1227 if opt_value: +1228 opt_value = opt_value.strip() +1229 yield opt_value + 1230 +1231 - def add(self, item): + 1232 for option in self.options: -1231 opt_value = option.1233 opt_value = option.get('value') -1232 if opt_value is None: -1233 opt_value = option.1234 if opt_value is None: +1235 opt_value = option.text or '' -1234 if opt_value: -1235 opt_value = opt_value.strip() -1236 if opt_value == item: -1237 option.1236 if opt_value: +1237 opt_value = opt_value.strip() +1238 if opt_value == item: +1239 option.set('selected', '') -1238 break -1239 else: -1240 raise ValueError( -1241 "There is no option with the value %r" % item) - 1242 -1243 - def remove(self, item): - 1244 for option in self.1240 break +1241 else: +1242 raise ValueError( +1243 "There is no option with the value %r" % item) + 1244 +1245 - def remove(self, item): + 1246 for option in self.options: -1245 opt_value = option.1247 opt_value = option.get('value') -1246 if opt_value is None: -1247 opt_value = option.1248 if opt_value is None: +1249 opt_value = option.text or '' -1248 if opt_value: -1249 opt_value = opt_value.strip() -1250 if opt_value == item: -1251 if 'selected' in option.1250 if opt_value: +1251 opt_value = opt_value.strip() +1252 if opt_value == item: +1253 if 'selected' in option.attrib: -1252 del option.1254 del option.attrib['selected'] -1253 else: -1254 raise ValueError( -1255 "The option %r is not currently selected" % item) -1256 break -1257 else: -1258 raise ValueError( -1259 "There is not option with the value %r" % item) - 1260 -1261 - def __repr__(self): - 1262 return '<%s {%s} for select name=%r>' % ( -1263 self.__class__.__name__, -1264 ', '.join([repr(v) for v in self]), -1265 self.select.1255 else: +1256 raise ValueError( +1257 "The option %r is not currently selected" % item) +1258 break +1259 else: +1260 raise ValueError( +1261 "There is not option with the value %r" % item) + 1262 +1263 - def __repr__(self): + 1264 return '<%s {%s} for select name=%r>' % ( +1265 self.__class__.__name__, +1266 ', '.join([repr(v) for v in self]), +1267 self.select.name) - 1266 -1267 -class RadioGroup(list): - 1268 """ -1269 This object represents several ``<input type=radio>`` elements -1270 that have the same name. -1271 -1272 You can use this like a list, but also use the property -1273 ``.value`` to check/uncheck inputs. Also you can use -1274 ``.value_options`` to get the possible values. -1275 """ -1276 -1277 - def _value__get(self): - 1278 """ -1279 Get/set the value, which checks the radio with that value (and -1280 unchecks any other value). -1281 """ -1282 for el in self: -1283 if 'checked' in el.1268 +1269 -class RadioGroup(list): + 1270 """ +1271 This object represents several ``<input type=radio>`` elements +1272 that have the same name. +1273 +1274 You can use this like a list, but also use the property +1275 ``.value`` to check/uncheck inputs. Also you can use +1276 ``.value_options`` to get the possible values. +1277 """ +1278 +1279 - def _value__get(self): + 1280 """ +1281 Get/set the value, which checks the radio with that value (and +1282 unchecks any other value). +1283 """ +1284 for el in self: +1285 if 'checked' in el.attrib: -1284 return el.1286 return el.get('value') -1285 return None - 1286 -1287 - def _value__set(self, value): - 1288 if 1287 return None + 1288 +1289 - def _value__set(self, value): + 1290 if value is not None: -1289 for el in self: -1290 if el.1291 for el in self: +1292 if el.get('value') == value: -1291 checked_option = el -1292 break -1293 else: -1294 raise ValueError( -1295 "There is no radio input with the value %r" % 1293 checked_option = el +1294 break +1295 else: +1296 raise ValueError( +1297 "There is no radio input with the value %r" % value) -1296 for el in self: -1297 if 'checked' in el.1298 for el in self: +1299 if 'checked' in el.attrib: -1298 del el.1300 del el.attrib['checked'] -1299 if 1301 if value is not None: -1300 checked_option.1302 checked_option.set('checked', '') - 1301 -1302 - def _value__del(self): - 1303 self.1303 +1304 - def _value__del(self): + 1305 self.value = None - 1304 -1305 1306 +1307 _value__get.__doc__) -1306 -1307 - def value_options(self): - 1308 """ -1309 Returns a list of all the possible values. -1310 """ -1311 return [el.1308 +1309 - def value_options(self): + 1310 """ +1311 Returns a list of all the possible values. +1312 """ +1313 return [el.get('value') for el in self] - 1312 1314 value_options = property(value_options.__doc__) -1313 -1314 - def __repr__(self): - 1315 return '%s(%s)' % ( -1316 self.__class__.__name__, -1317 list.1315 +1316 - def __repr__(self): + 1317 return '%s(%s)' % ( +1318 self.__class__.__name__, +1319 list.__repr__(self)) - 1318 -1319 -class CheckboxGroup(list): - 1320 """ -1321 Represents a group of checkboxes (``<input type=checkbox>``) that -1322 have the same name. -1323 -1324 In addition to using this like a list, the ``.value`` attribute -1325 returns a set-like object that you can add to or remove from to -1326 check and uncheck checkboxes. You can also use ``.value_options`` -1327 to get the possible values. -1328 """ -1329 -1330 - def _value__get(self): - 1331 """ -1332 Return a set-like object that can be modified to check or -1333 uncheck individual checkboxes according to their value. -1334 """ -1335 return CheckboxValues(self) - 1336 - def _value__set(self, value): - 1337 self.1320 +1321 -class CheckboxGroup(list): + 1322 """ +1323 Represents a group of checkboxes (``<input type=checkbox>``) that +1324 have the same name. +1325 +1326 In addition to using this like a list, the ``.value`` attribute +1327 returns a set-like object that you can add to or remove from to +1328 check and uncheck checkboxes. You can also use ``.value_options`` +1329 to get the possible values. +1330 """ +1331 +1332 - def _value__get(self): + 1333 """ +1334 Return a set-like object that can be modified to check or +1335 uncheck individual checkboxes according to their value. +1336 """ +1337 return CheckboxValues(self) + 1338 - def _value__set(self, value): + 1339 self.value.clear() -1338 if not hasattr(1340 if not hasattr(value, '__iter__'): -1339 raise ValueError( -1340 "A CheckboxGroup (name=%r) must be set to a sequence (not %r)" -1341 % (self[0].1341 raise ValueError( +1342 "A CheckboxGroup (name=%r) must be set to a sequence (not %r)" +1343 % (self[0].name, value)) -1342 self.1344 self.value) - 1343 - def _value__del(self): - 1344 self.1345 - def _value__del(self): + 1346 self.value.clear() - 1345 1347 _value__get.__doc__) -1346 -1347 - def value_options(self): - 1348 """ -1349 Returns a list of all the possible values. -1350 """ -1351 return [el.1348 +1349 - def value_options(self): + 1350 """ +1351 Returns a list of all the possible values. +1352 """ +1353 return [el.get('value') for el in self] - 1352 1354 value_options = property(value_options.__doc__) -1353 -1354 - def __repr__(self): - 1355 return '%s(%s)' % ( -1356 self.__class__.__name__, list.1355 +1356 - def __repr__(self): + 1357 return '%s(%s)' % ( +1358 self.__class__.__name__, list.__repr__(self)) - 1357 -1358 -class CheckboxValues(SetMixin): - 1359 -1360 """ -1361 Represents the values of the checked checkboxes in a group of -1362 checkboxes with the same name. -1363 """ -1364 -1365 - def __init__(self, group): - 1366 self.group = group - 1367 -1368 - def __iter__(self): - 1369 return 1359 +1360 -class CheckboxValues(SetMixin): + 1361 +1362 """ +1363 Represents the values of the checked checkboxes in a group of +1364 checkboxes with the same name. +1365 """ +1366 +1367 - def __init__(self, group): + 1368 self.group = group + 1369 +1370 - def __iter__(self): + 1371 return iter([ -1370 el.1372 el.get('value') -1371 for el in self.group -1372 if 'checked' in el.1373 for el in self.group +1374 if 'checked' in el.attrib]) - 1373 -1374 - def add(self, value): - 1375 for el in self.group: -1376 if el.1375 +1376 - def add(self, value): + 1377 for el in self.group: +1378 if el.get('value') == value: -1377 el.1379 el.set('checked', '') -1378 break -1379 else: -1380 raise KeyError("No checkbox with value %r" % 1380 break +1381 else: +1382 raise KeyError("No checkbox with value %r" % value) - 1381 -1382 - def remove(self, value): - 1383 for el in self.group: -1384 if el.1383 +1384 - def remove(self, value): + 1385 for el in self.group: +1386 if el.get('value') == value: -1385 if 'checked' in el.1387 if 'checked' in el.attrib: -1386 del el.1388 del el.attrib['checked'] -1387 else: -1388 raise KeyError( -1389 "The checkbox with value %r was already unchecked" % 1389 else: +1390 raise KeyError( +1391 "The checkbox with value %r was already unchecked" % value) -1390 break -1391 else: -1392 raise KeyError( -1393 "No checkbox with value %r" % 1392 break +1393 else: +1394 raise KeyError( +1395 "No checkbox with value %r" % value) - 1394 -1395 - def __repr__(self): - 1396 return '<%s {%s} for checkboxes name=%r>' % ( -1397 self.__class__.__name__, -1398 ', '.join([repr(v) for v in self]), -1399 self.group.1396 +1397 - def __repr__(self): + 1398 return '<%s {%s} for checkboxes name=%r>' % ( +1399 self.__class__.__name__, +1400 ', '.join([repr(v) for v in self]), +1401 self.group.name) - 1400 -1401 -class InputElement(InputMixin, HtmlElement): - 1402 """ -1403 Represents an ``<input>`` element. -1404 -1405 You can get the type with ``.type`` (which is lower-cased and -1406 defaults to ``'text'``). -1407 -1408 Also you can get and set the value with ``.value`` + 1402 +1403 -class InputElement(InputMixin, HtmlElement): + 1404 """ +1405 Represents an ``<input>`` element. +1406 +1407 You can get the type with ``.type`` (which is lower-cased and +1408 defaults to ``'text'``). 1409 -1410 Checkboxes and radios have the attribute ``input.checkable == -1411 True`` (for all others it is false) and a boolean attribute -1412 ``.checked``. -1413 -1414 """ -1415 -1416 ## FIXME: I'm a little uncomfortable with the use of .checked -1417 - def _value__get(self): - 1418 """ -1419 Get/set the value of this element, using the ``value`` attribute. -1420 -1421 Also, if this is a checkbox and it has no value, this defaults -1422 to ``'on'``. If it is a checkbox or radio that is not -1423 checked, this returns None. -1424 """ -1425 if self.checkable: -1426 if self.checked: -1427 return self.1410 Also you can get and set the value with ``.value`` +1411 +1412 Checkboxes and radios have the attribute ``input.checkable == +1413 True`` (for all others it is false) and a boolean attribute +1414 ``.checked``. +1415 +1416 """ +1417 +1418 ## FIXME: I'm a little uncomfortable with the use of .checked +1419 - def _value__get(self): + 1420 """ +1421 Get/set the value of this element, using the ``value`` attribute. +1422 +1423 Also, if this is a checkbox and it has no value, this defaults +1424 to ``'on'``. If it is a checkbox or radio that is not +1425 checked, this returns None. +1426 """ +1427 if self.checkable: +1428 if self.checked: +1429 return self.get('value') or 'on' -1428 else: -1429 return None -1430 return self.1430 else: +1431 return None +1432 return self.get('value') - 1431 - def _value__set(self, value): - 1432 if self.checkable: -1433 if not 1433 - def _value__set(self, value): + 1434 if self.checkable: +1435 if not value: -1434 self.checked = False -1435 else: -1436 self.checked = True -1437 if isinstance(1436 self.checked = False +1437 else: +1438 self.checked = True +1439 if isinstance(value, basestring): -1438 self.1440 self.set('value', value) -1439 else: -1440 self.1441 else: +1442 self.set('value', value) - 1441 - def _value__del(self): - 1442 if self.checkable: -1443 self.checked = False -1444 else: -1445 if 'value' in self.1443 - def _value__del(self): + 1444 if self.checkable: +1445 self.checked = False +1446 else: +1447 if 'value' in self.attrib: -1446 del self.1448 del self.attrib['value'] - 1447 1449 _value__get.__doc__) -1448 -1449 - def _type__get(self): - 1450 """ -1451 Return the type of this element (using the type attribute). -1452 """ -1453 return self.1450 +1451 - def _type__get(self): + 1452 """ +1453 Return the type of this element (using the type attribute). +1454 """ +1455 return self.get('type', 'text').lower() - 1454 - def _type__set(self, value): - 1455 self.1456 - def _type__set(self, value): + 1457 self.set('type', value) - 1456 1458 type = property(_type__get, _type__set, doc=_type__get.__doc__) -1457 -1458 - def checkable(self): - 1459 """ -1460 Boolean: can this element be checked? -1461 """ -1462 return self.1459 +1460 - def checkable(self): + 1461 """ +1462 Boolean: can this element be checked? +1463 """ +1464 return self.type in ['checkbox', 'radio'] - 1463 checkable = property(checkable, doc=checkable.1465 checkable = property(checkable, doc=checkable.__doc__) -1464 -1465 - def _checked__get(self): - 1466 """ -1467 Boolean attribute to get/set the presence of the ``checked`` -1468 attribute. -1469 -1470 You can only use this on checkable input types. -1471 """ -1472 if not self.checkable: -1473 raise AttributeError('Not a checkable input type') -1474 return 'checked' in self.1466 +1467 - def _checked__get(self): + 1468 """ +1469 Boolean attribute to get/set the presence of the ``checked`` +1470 attribute. +1471 +1472 You can only use this on checkable input types. +1473 """ +1474 if not self.checkable: +1475 raise AttributeError('Not a checkable input type') +1476 return 'checked' in self.attrib - 1475 - def _checked__set(self, value): - 1476 if not self.checkable: -1477 raise AttributeError('Not a checkable input type') -1478 if 1477 - def _checked__set(self, value): + 1478 if not self.checkable: +1479 raise AttributeError('Not a checkable input type') +1480 if value: -1479 self.1481 self.set('checked', '') -1480 else: -1481 if 'checked' in self.1482 else: +1483 if 'checked' in self.attrib: -1482 del self.1484 del self.attrib['checked'] - 1483 checked = property(_checked__get, _checked__set, doc=_checked__get.1485 checked = property(_checked__get, _checked__set, doc=_checked__get.__doc__) - 1484 -1485 HtmlElementClassLookup._default_element_classes['input'] = InputElement -1486 -1487 -class LabelElement(HtmlElement): - 1488 """ -1489 Represents a ``<label>`` element. -1490 -1491 Label elements are linked to other elements with their ``for`` -1492 attribute. You can access this element with ``label.for_element``. -1493 """ -1494 -1495 - def _for_element__get(self): - 1496 """ -1497 Get/set the element this label points to. Return None if it -1498 can't be found. -1499 """ -1500 id = self.1486 +1487 HtmlElementClassLookup._default_element_classes['input'] = InputElement +1488 +1489 -class LabelElement(HtmlElement): + 1490 """ +1491 Represents a ``<label>`` element. +1492 +1493 Label elements are linked to other elements with their ``for`` +1494 attribute. You can access this element with ``label.for_element``. +1495 """ +1496 +1497 - def _for_element__get(self): + 1498 """ +1499 Get/set the element this label points to. Return None if it +1500 can't be found. +1501 """ +1502 id = self.get('for') -1501 if not id: -1502 return None -1503 return self.body.get_element_by_id(id) - 1504 - def _for_element__set(self, other): - 1505 id = other.1503 if not id: +1504 return None +1505 return self.body.get_element_by_id(id) + 1506 - def _for_element__set(self, other): + 1507 id = other.get('id') -1506 if not id: -1507 raise TypeError( -1508 "Element %r has no id attribute" % other) -1509 self.1508 if not id: +1509 raise TypeError( +1510 "Element %r has no id attribute" % other) +1511 self.set('for', id) - 1510 - def _for_element__del(self): - 1511 if 'id' in self.1512 - def _for_element__del(self): + 1513 if 'id' in self.attrib: -1512 del self.1514 del self.attrib['id'] - 1513 for_element = property(_for_element__get, _for_element__set, _for_element__del, -1514 doc=_for_element__get.1515 for_element = property(_for_element__get, _for_element__set, _for_element__del, +1516 doc=_for_element__get.__doc__) - 1515 -1516 HtmlElementClassLookup._default_element_classes['label'] = LabelElement -1517 -1518 ############################################################ -1519 ## Serialization + 1517 +1518 HtmlElementClassLookup._default_element_classes['label'] = LabelElement +1519 1520 ############################################################ -1521 -1522 -def html_to_xhtml(html): - 1523 """Convert all tags in an HTML tree to XHTML by moving them to the -1524 XHTML namespace. -1525 """ -1526 try: -1527 1521 ## Serialization +1522 ############################################################ +1523 +1524 -def html_to_xhtml(html): + 1525 """Convert all tags in an HTML tree to XHTML by moving them to the +1526 XHTML namespace. +1527 """ +1528 try: +1529 html = html.getroot() -1528 except AttributeError: -1529 pass -1530 prefix = "{%s}" % XHTML_NAMESPACE -1531 for el in 1530 except AttributeError: +1531 pass +1532 prefix = "{%s}" % XHTML_NAMESPACE +1533 for el in html.Element): -1532 1534 tag -1533 if 1535 if tag[0] != '{': -1534 el.1536 el.tag - 1535 -1536 -def xhtml_to_html(xhtml): - 1537 """Convert all tags in an XHTML tree to HTML by removing their -1538 XHTML namespace. -1539 """ -1540 try: -1541 xhtml = xhtml.getroot() -1542 except AttributeError: -1543 pass -1544 prefix = "{%s}" % XHTML_NAMESPACE -1545 prefix_len = len(prefix) -1546 for el in xhtml.1537 +1538 -def xhtml_to_html(xhtml): + 1539 """Convert all tags in an XHTML tree to HTML by removing their +1540 XHTML namespace. +1541 """ +1542 try: +1543 xhtml = xhtml.getroot() +1544 except AttributeError: +1545 pass +1546 prefix = "{%s}" % XHTML_NAMESPACE +1547 prefix_len = len(prefix) +1548 for el in xhtml.iter(prefix + "*"): -1547 el.1549 el.tag[prefix_len:] - 1548 -1549 # This isn't a general match, but it's a match for what libxml2 -1550 # specifically serialises: -1551 __str_replace_meta_content_type = re.compile( -1552 r'<meta http-equiv="Content-Type"[^>]*>').sub -1553 __bytes_replace_meta_content_type = re.compile( -1554 r'<meta http-equiv="Content-Type"[^>]*>'.encode('ASCII')).sub -1555 -1556 -def tostring(doc, pretty_print=False, include_meta_content_type=False, -1557 encoding=None, method="html", with_tail=True, doctype=None): - 1558 """Return an HTML string representation of the document. -1559 -1560 Note: if include_meta_content_type is true this will create a -1561 ``<meta http-equiv="Content-Type" ...>`` tag in the head; -1562 regardless of the value of include_meta_content_type any existing -1563 ``<meta http-equiv="Content-Type" ...>`` tag will be removed -1564 -1565 The ``encoding`` argument controls the output encoding (defauts to -1566 ASCII, with &#...; character references for any characters outside -1567 of ASCII). Note that you can pass the name ``'unicode'`` as -1568 ``encoding`` argument to serialise to a Unicode string. -1569 -1570 The ``method`` argument defines the output method. It defaults to -1571 'html', but can also be 'xml' for xhtml output, or 'text' to -1572 serialise to plain text without markup. -1573 -1574 To leave out the tail text of the top-level element that is being -1575 serialised, pass ``with_tail=False``. -1576 -1577 The ``doctype`` option allows passing in a plain string that will -1578 be serialised before the XML tree. Note that passing in non -1579 well-formed content here will make the XML output non well-formed. -1580 Also, an existing doctype in the document tree will not be removed -1581 when serialising an ElementTree instance. -1582 -1583 Example:: + 1550 +1551 # This isn't a general match, but it's a match for what libxml2 +1552 # specifically serialises: +1553 __str_replace_meta_content_type = re.compile( +1554 r'<meta http-equiv="Content-Type"[^>]*>').sub +1555 __bytes_replace_meta_content_type = re.compile( +1556 r'<meta http-equiv="Content-Type"[^>]*>'.encode('ASCII')).sub +1557 +1558 -def tostring(doc, pretty_print=False, include_meta_content_type=False, +1559 encoding=None, method="html", with_tail=True, doctype=None): + 1560 """Return an HTML string representation of the document. +1561 +1562 Note: if include_meta_content_type is true this will create a +1563 ``<meta http-equiv="Content-Type" ...>`` tag in the head; +1564 regardless of the value of include_meta_content_type any existing +1565 ``<meta http-equiv="Content-Type" ...>`` tag will be removed +1566 +1567 The ``encoding`` argument controls the output encoding (defauts to +1568 ASCII, with &#...; character references for any characters outside +1569 of ASCII). Note that you can pass the name ``'unicode'`` as +1570 ``encoding`` argument to serialise to a Unicode string. +1571 +1572 The ``method`` argument defines the output method. It defaults to +1573 'html', but can also be 'xml' for xhtml output, or 'text' to +1574 serialise to plain text without markup. +1575 +1576 To leave out the tail text of the top-level element that is being +1577 serialised, pass ``with_tail=False``. +1578 +1579 The ``doctype`` option allows passing in a plain string that will +1580 be serialised before the XML tree. Note that passing in non +1581 well-formed content here will make the XML output non well-formed. +1582 Also, an existing doctype in the document tree will not be removed +1583 when serialising an ElementTree instance. 1584 -1585 >>> from lxml import html -1586 >>> root = html.fragment_fromstring('<p>Hello<br>world!</p>') -1587 -1588 >>> html.tostring(root) -1589 b'<p>Hello<br>world!</p>' -1590 >>> html.tostring(root, method='html') +1585 Example:: +1586 +1587 >>> from lxml import html +1588 >>> root = html.fragment_fromstring('<p>Hello<br>world!</p>') +1589 +1590 >>> html.tostring(root) 1591 b'<p>Hello<br>world!</p>' -1592 -1593 >>> html.tostring(root, method='xml') -1594 b'<p>Hello<br/>world!</p>' -1595 -1596 >>> html.tostring(root, method='text') -1597 b'Helloworld!' -1598 -1599 >>> html.tostring(root, method='text', encoding='unicode') -1600 u'Helloworld!' -1601 -1602 >>> root = html.fragment_fromstring('<div><p>Hello<br>world!</p>TAIL</div>') -1603 >>> html.tostring(root[0], method='text', encoding='unicode') -1604 u'Helloworld!TAIL' -1605 -1606 >>> html.tostring(root[0], method='text', encoding='unicode', with_tail=False) -1607 u'Helloworld!' -1608 -1609 >>> doc = html.document_fromstring('<p>Hello<br>world!</p>') -1610 >>> html.tostring(doc, method='html', encoding='unicode') -1611 u'<html><body><p>Hello<br>world!</p></body></html>' -1612 -1613 >>> print(html.tostring(doc, method='html', encoding='unicode', -1614 ... doctype='<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"' -1615 ... ' "http://www.w3.org/TR/html4/strict.dtd">')) -1616 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> -1617 <html><body><p>Hello<br>world!</p></body></html> -1618 """ -1619 1592 >>> html.tostring(root, method='html') +1593 b'<p>Hello<br>world!</p>' +1594 +1595 >>> html.tostring(root, method='xml') +1596 b'<p>Hello<br/>world!</p>' +1597 +1598 >>> html.tostring(root, method='text') +1599 b'Helloworld!' +1600 +1601 >>> html.tostring(root, method='text', encoding='unicode') +1602 u'Helloworld!' +1603 +1604 >>> root = html.fragment_fromstring('<div><p>Hello<br>world!</p>TAIL</div>') +1605 >>> html.tostring(root[0], method='text', encoding='unicode') +1606 u'Helloworld!TAIL' +1607 +1608 >>> html.tostring(root[0], method='text', encoding='unicode', with_tail=False) +1609 u'Helloworld!' +1610 +1611 >>> doc = html.document_fromstring('<p>Hello<br>world!</p>') +1612 >>> html.tostring(doc, method='html', encoding='unicode') +1613 u'<html><body><p>Hello<br>world!</p></body></html>' +1614 +1615 >>> print(html.tostring(doc, method='html', encoding='unicode', +1616 ... doctype='<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"' +1617 ... ' "http://www.w3.org/TR/html4/strict.dtd">')) +1618 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +1619 <html><body><p>Hello<br>world!</p></body></html> +1620 """ +1621 html = etree.tostring(doc, method=method, pretty_print=pretty_print, -1620 encoding=encoding, with_tail=with_tail, -1621 doctype=doctype) -1622 if method == 'html' and not include_meta_content_type: -1623 if isinstance(1622 encoding=encoding, with_tail=with_tail, +1623 doctype=doctype) +1624 if method == 'html' and not include_meta_content_type: +1625 if isinstance(html, str): -1624 1626 html = __str_replace_meta_content_type('', html) -1625 else: -1626 1627 else: +1628 html = __bytes_replace_meta_content_type(bytes(), html) -1627 return 1629 return html - 1628 -1629 1630 +1631 tostring.__doc__ = __fix_docstring(tostring.__doc__) -1630 -1631 -def open_in_browser(doc, encoding=None): - 1632 """ -1633 Open the HTML document in a web browser, saving it to a temporary -1634 file to open it. Note that this does not delete the file after -1635 use. This is mainly meant for debugging. -1636 """ -1637 import os -1638 import webbrowser -1639 import tempfile -1640 if not isinstance(doc, 1632 +1633 -def open_in_browser(doc, encoding=None): + 1634 """ +1635 Open the HTML document in a web browser, saving it to a temporary +1636 file to open it. Note that this does not delete the file after +1637 use. This is mainly meant for debugging. +1638 """ +1639 import os +1640 import webbrowser +1641 import tempfile +1642 if not isinstance(doc, etree._ElementTree): -1641 doc = 1643 doc = etree.ElementTree(doc) -1642 1644 handle, fn = tempfile.mkstemp(suffix='.html') -1643 f = os.fdopen(1645 f = os.fdopen(handle, 'wb') -1644 try: -1645 doc.write(f, method="html", encoding=encoding or doc.docinfo.encoding or "UTF-8") -1646 finally: -1647 # we leak the file itself here, but we should at least close it -1648 f.1646 try: +1647 doc.write(f, method="html", encoding=encoding or doc.docinfo.encoding or "UTF-8") +1648 finally: +1649 # we leak the file itself here, but we should at least close it +1650 f.close() -1649 url = 'file://' + fn.replace(os.path.sep, '/') -1650 print(url) -1651 webbrowser.open(url) - 1652 -1653 ################################################################################ -1654 # configure Element class lookup +1651 url = 'file://' + fn.replace(os.path.sep, '/') +1652 print(url) +1653 webbrowser.open(url) + 1654 1655 ################################################################################ -1656 -1657 -class HTMLParser(etree.HTMLParser): - 1658 """An HTML parser that is configured to return lxml.html Element -1659 objects. -1660 """ -1661 - def __init__(self, **kwargs): - 1662 super(1656 # configure Element class lookup +1657 ################################################################################ +1658 +1659 -class HTMLParser(etree.HTMLParser): + 1660 """An HTML parser that is configured to return lxml.html Element +1661 objects. +1662 """ +1663 - def __init__(self, **kwargs): + 1664 super(HTMLParser, self).__init__(**kwargs) -1663 self.1665 self.set_element_class_lookup(HtmlElementClassLookup()) - 1664 -1665 -class XHTMLParser(etree.XMLParser): - 1666 """An XML parser that is configured to return lxml.html Element -1667 objects. -1668 -1669 Note that this parser is not really XHTML aware unless you let it -1670 load a DTD that declares the HTML entities. To do this, make sure -1671 you have the XHTML DTDs installed in your catalogs, and create the -1672 parser like this:: -1673 -1674 >>> parser = XHTMLParser(load_dtd=True) + 1666 +1667 -class XHTMLParser(etree.XMLParser): + 1668 """An XML parser that is configured to return lxml.html Element +1669 objects. +1670 +1671 Note that this parser is not really XHTML aware unless you let it +1672 load a DTD that declares the HTML entities. To do this, make sure +1673 you have the XHTML DTDs installed in your catalogs, and create the +1674 parser like this:: 1675 -1676 If you additionally want to validate the document, use this:: +1676 >>> parser = XHTMLParser(load_dtd=True) 1677 -1678 >>> parser = XHTMLParser(dtd_validation=True) +1678 If you additionally want to validate the document, use this:: 1679 -1680 For catalog support, see http://www.xmlsoft.org/catalog.html. -1681 """ -1682 - def __init__(self, **kwargs): - 1683 super(1680 >>> parser = XHTMLParser(dtd_validation=True) +1681 +1682 For catalog support, see http://www.xmlsoft.org/catalog.html. +1683 """ +1684 - def __init__(self, **kwargs): + 1685 super(XHTMLParser, self).__init__(**kwargs) -1684 self.1686 self.set_element_class_lookup(HtmlElementClassLookup()) - 1685 -1686 -def Element(*args, **kw): - 1687 """Create a new HTML Element. -1688 -1689 This can also be used for XHTML documents. -1690 """ -1691 v = 1687 +1688 -def Element(*args, **kw): + 1689 """Create a new HTML Element. +1690 +1691 This can also be used for XHTML documents. +1692 """ +1693 v = html_parser.makeelement(*args, **kw) -1692 return v - 1693 -1694 1694 return v + 1695 +1696 html_parser = HTMLParser() -1695 1697 xhtml_parser = XHTMLParser() -1696

lxml FAQ - Frequently Asked Questions

lxml FAQ - Frequently Asked Questions

APIs specific to lxml.etree

APIs specific to lxml.etree