/usr/share/pyshared/quixote/html/_py_htmltext.py is in python-quixote 2.7~b2-1+b2.
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 | """Python implementation of the htmltext type, the htmlescape function and
TemplateIO.
"""
def _escape_string(s):
if not isinstance(s, basestring):
raise TypeError, 'string object required'
s = s.replace("&", "&")
s = s.replace("<", "<")
s = s.replace(">", ">")
s = s.replace('"', """)
return s
def stringify(obj):
"""Return 'obj' as a string or unicode object. Tries to prevent
turning strings into unicode objects.
"""
tp = type(obj)
if issubclass(tp, basestring):
return obj
elif hasattr(tp, '__unicode__'):
s = tp.__unicode__(obj)
if not isinstance(s, basestring):
raise TypeError, '__unicode__ did not return a string'
return s
elif hasattr(tp, '__str__'):
s = tp.__str__(obj)
if not isinstance(s, basestring):
raise TypeError, '__str__ did not return a string'
return s
else:
return str(obj)
class htmltext(object):
"""The htmltext string-like type. This type serves as a tag
signifying that HTML special characters do not need to be escaped
using entities.
"""
__slots__ = ['s']
def __init__(self, s):
self.s = stringify(s)
# XXX make read-only
#def __setattr__(self, name, value):
# raise AttributeError, 'immutable object'
def __getstate__(self):
raise ValueError, 'htmltext objects should not be pickled'
def __repr__(self):
return '<htmltext %r>' % self.s
def __str__(self):
return self.s
def __len__(self):
return len(self.s)
def __cmp__(self, other):
return cmp(self.s, other)
def __hash__(self):
return hash(self.s)
def __mod__(self, args):
if isinstance(args, tuple):
return htmltext(self.s % tuple(map(_wraparg, args)))
else:
return htmltext(self.s % _wraparg(args))
def __add__(self, other):
if isinstance(other, basestring):
return htmltext(self.s + _escape_string(other))
elif isinstance(other, htmltext):
return htmltext(self.s + other.s)
else:
return NotImplemented
def __radd__(self, other):
if isinstance(other, basestring):
return htmltext(_escape_string(other) + self.s)
else:
return NotImplemented
def __mul__(self, n):
return htmltext(self.s * n)
def join(self, items):
quoted_items = []
for item in items:
if isinstance(item, htmltext):
quoted_items.append(stringify(item))
elif isinstance(item, basestring):
quoted_items.append(_escape_string(item))
else:
raise TypeError(
'join() requires string arguments (got %r)' % item)
return htmltext(self.s.join(quoted_items))
def startswith(self, s):
if isinstance(s, htmltext):
s = s.s
else:
s = _escape_string(s)
return self.s.startswith(s)
def endswith(self, s):
if isinstance(s, htmltext):
s = s.s
else:
s = _escape_string(s)
return self.s.endswith(s)
def replace(self, old, new, count=-1):
if isinstance(old, htmltext):
old = old.s
else:
old = _escape_string(old)
if isinstance(new, htmltext):
new = new.s
else:
new = _escape_string(new)
return htmltext(self.s.replace(old, new, count))
def lower(self):
return htmltext(self.s.lower())
def upper(self):
return htmltext(self.s.upper())
def capitalize(self):
return htmltext(self.s.capitalize())
class _QuoteWrapper(object):
# helper for htmltext class __mod__
__slots__ = ['value']
def __init__(self, value):
self.value = value
def __str__(self):
return _escape_string(stringify(self.value))
def __repr__(self):
return _escape_string(`self.value`)
def __getitem__(self, key):
return _wraparg(self.value[key])
class _UnicodeWrapper(unicode):
__slots__ = ['raw']
def __new__(cls, s):
result = unicode.__new__(cls, _escape_string(s))
result.raw = s
return result
def __repr__(self):
return _escape_string(`self.raw`)
def _wraparg(arg):
if isinstance(arg, htmltext):
# necessary to work around a PyString_Format bug in Python. Should
# be fixed in Python 2.5
return stringify(arg)
elif isinstance(arg, unicode):
# again, work around PyString_Format bug
return _UnicodeWrapper(arg)
elif (isinstance(arg, int) or
isinstance(arg, long) or
isinstance(arg, float)):
# ints, longs, floats are okay
return arg
else:
# everything is gets wrapped
return _QuoteWrapper(arg)
def htmlescape(s):
"""htmlescape(s) -> htmltext
Return an 'htmltext' object using the argument. If the argument is not
already a 'htmltext' object then the HTML markup characters \", <, >,
and & are first escaped.
"""
if isinstance(s, htmltext):
return s
else:
s = stringify(s)
# inline _escape_string for speed
s = s.replace("&", "&") # must be done first
s = s.replace("<", "<")
s = s.replace(">", ">")
s = s.replace('"', """)
return htmltext(s)
class TemplateIO(object):
"""Collect output for PTL scripts.
"""
__slots__ = ['html', 'data']
def __init__(self, html=False):
self.html = html
self.data = []
def __iadd__(self, other):
if other is not None:
self.data.append(other)
return self
def __repr__(self):
return ("<%s at %x: %d chunks>" %
(self.__class__.__name__, id(self), len(self.data)))
def __str__(self):
return stringify(self.getvalue())
def getvalue(self):
if self.html:
return htmltext('').join(map(htmlescape, self.data))
else:
return ''.join(map(stringify, self.data))
|