| * | * should pop to 'tr', not the first 'td'
- """
-
- nestingResetTriggers = self.NESTABLE_TAGS.get(name)
- isNestable = nestingResetTriggers != None
- isResetNesting = self.RESET_NESTING_TAGS.has_key(name)
- popTo = None
- inclusive = True
- for i in range(len(self.tagStack)-1, 0, -1):
- p = self.tagStack[i]
- if (not p or p.name == name) and not isNestable:
- # Non-nestable tags get popped to the top or to their
- # last occurance.
- popTo = name
- break
- if (nestingResetTriggers is not None
- and p.name in nestingResetTriggers) \
- or (nestingResetTriggers is None and isResetNesting
- and self.RESET_NESTING_TAGS.has_key(p.name)):
-
- # If we encounter one of the nesting reset triggers
- # peculiar to this tag, or we encounter another tag
- # that causes nesting to reset, pop up to but not
- # including that tag.
- popTo = p.name
- inclusive = False
- break
- p = p.parent
- if popTo:
- self._popToTag(popTo, inclusive)
-
- def unknown_starttag(self, name, attrs, selfClosing=0):
- # print "Start tag %s: %s" % (name, attrs)
- if self.quoteStack:
- # This is not a real tag.
- # print "<%s> is not real!" % name
- attrs = ''.join([' %s="%s"' % (x, y) for x, y in attrs])
- self.handle_data('<%s%s>' % (name, attrs))
- return
- self.endData()
-
- if not self.isSelfClosingTag(name) and not selfClosing:
- self._smartPop(name)
-
- if self.parseOnlyThese and len(self.tagStack) <= 1 \
- and (self.parseOnlyThese.text or not self.parseOnlyThese.searchTag(name, attrs)):
- return
-
- tag = Tag(self, name, attrs, self.currentTag, self.previous)
- if self.previous:
- self.previous.next = tag
- self.previous = tag
- self.pushTag(tag)
- if selfClosing or self.isSelfClosingTag(name):
- self.popTag()
- if name in self.QUOTE_TAGS:
- # print "Beginning quote (%s)" % name
- self.quoteStack.append(name)
- self.literal = 1
- return tag
-
- def unknown_endtag(self, name):
- # print "End tag %s" % name
- if self.quoteStack and self.quoteStack[-1] != name:
- # This is not a real end tag.
- # print " is not real!" % name
- self.handle_data('' % name)
- return
- self.endData()
- self._popToTag(name)
- if self.quoteStack and self.quoteStack[-1] == name:
- self.quoteStack.pop()
- self.literal = (len(self.quoteStack) > 0)
-
- def handle_data(self, data):
- self.currentData.append(data)
-
- def _toStringSubclass(self, text, subclass):
- """Adds a certain piece of text to the tree as a NavigableString
- subclass."""
- self.endData()
- self.handle_data(text)
- self.endData(subclass)
-
- def handle_pi(self, text):
- """Handle a processing instruction as a ProcessingInstruction
- object, possibly one with a %SOUP-ENCODING% slot into which an
- encoding will be plugged later."""
- if text[:3] == "xml":
- text = u"xml version='1.0' encoding='%SOUP-ENCODING%'"
- self._toStringSubclass(text, ProcessingInstruction)
-
- def handle_comment(self, text):
- "Handle comments as Comment objects."
- self._toStringSubclass(text, Comment)
-
- def handle_charref(self, ref):
- "Handle character references as data."
- if self.convertEntities:
- data = unichr(int(ref))
- else:
- data = '&#%s;' % ref
- self.handle_data(data)
-
- def handle_entityref(self, ref):
- """Handle entity references as data, possibly converting known
- HTML and/or XML entity references to the corresponding Unicode
- characters."""
- data = None
- if self.convertHTMLEntities:
- try:
- data = unichr(name2codepoint[ref])
- except KeyError:
- pass
-
- if not data and self.convertXMLEntities:
- data = self.XML_ENTITIES_TO_SPECIAL_CHARS.get(ref)
-
- if not data and self.convertHTMLEntities and \
- not self.XML_ENTITIES_TO_SPECIAL_CHARS.get(ref):
- # TODO: We've got a problem here. We're told this is
- # an entity reference, but it's not an XML entity
- # reference or an HTML entity reference. Nonetheless,
- # the logical thing to do is to pass it through as an
- # unrecognized entity reference.
- #
- # Except: when the input is "&carol;" this function
- # will be called with input "carol". When the input is
- # "AT&T", this function will be called with input
- # "T". We have no way of knowing whether a semicolon
- # was present originally, so we don't know whether
- # this is an unknown entity or just a misplaced
- # ampersand.
- #
- # The more common case is a misplaced ampersand, so I
- # escape the ampersand and omit the trailing semicolon.
- data = "&%s" % ref
- if not data:
- # This case is different from the one above, because we
- # haven't already gone through a supposedly comprehensive
- # mapping of entities to Unicode characters. We might not
- # have gone through any mapping at all. So the chances are
- # very high that this is a real entity, and not a
- # misplaced ampersand.
- data = "&%s;" % ref
- self.handle_data(data)
-
- def handle_decl(self, data):
- "Handle DOCTYPEs and the like as Declaration objects."
- self._toStringSubclass(data, Declaration)
-
- def parse_declaration(self, i):
- """Treat a bogus SGML declaration as raw data. Treat a CDATA
- declaration as a CData object."""
- j = None
- if self.rawdata[i:i+9] == '', i)
- if k == -1:
- k = len(self.rawdata)
- data = self.rawdata[i+9:k]
- j = k+3
- self._toStringSubclass(data, CData)
- else:
- try:
- j = SGMLParser.parse_declaration(self, i)
- except SGMLParseError:
- toHandle = self.rawdata[i:]
- self.handle_data(toHandle)
- j = i + len(toHandle)
- return j
-
-
-class BeautifulSoup(BeautifulStoneSoup):
-
- """This parser knows the following facts about HTML:
-
- * Some tags have no closing tag and should be interpreted as being
- closed as soon as they are encountered.
-
- * The text inside some tags (ie. 'script') may contain tags which
- are not really part of the document and which should be parsed
- as text, not tags. If you want to parse the text as tags, you can
- always fetch it and parse it explicitly.
-
- * Tag nesting rules:
-
- Most tags can't be nested at all. For instance, the occurance of
- a tag should implicitly close the previous tag.
-
- Para1 Para2
- should be transformed into:
- Para1 Para2
-
- Some tags can be nested arbitrarily. For instance, the occurance
- of a tag should _not_ implicitly close the previous
- tag.
-
- Alice said: Bob said: Blah
- should NOT be transformed into:
- Alice said: Bob said: Blah
-
- Some tags can be nested, but the nesting is reset by the
- interposition of other tags. For instance, a tag should
- implicitly close the previous tag within the same ,
- but not close a tag in another table.
-
- Blah Blah
- should be transformed into:
- Blah Blah
- but,
- BlahBlah
- should NOT be transformed into
- BlahBlah
-
- Differing assumptions about tag nesting rules are a major source
- of problems with the BeautifulSoup class. If BeautifulSoup is not
- treating as nestable a tag your page author treats as nestable,
- try ICantBelieveItsBeautifulSoup, MinimalSoup, or
- BeautifulStoneSoup before writing your own subclass."""
-
- def __init__(self, *args, **kwargs):
- if not kwargs.has_key('smartQuotesTo'):
- kwargs['smartQuotesTo'] = self.HTML_ENTITIES
- kwargs['isHTML'] = True
- BeautifulStoneSoup.__init__(self, *args, **kwargs)
-
- SELF_CLOSING_TAGS = buildTagMap(None,
- ('br', 'hr', 'input', 'img', 'meta',
- 'spacer', 'link', 'frame', 'base', 'col'))
-
- PRESERVE_WHITESPACE_TAGS = set(['pre', 'textarea'])
-
- QUOTE_TAGS = {'script': None, 'textarea': None}
-
- # According to the HTML standard, each of these inline tags can
- # contain another tag of the same type. Furthermore, it's common
- # to actually use these tags this way.
- NESTABLE_INLINE_TAGS = ('span', 'font', 'q', 'object', 'bdo', 'sub', 'sup',
- 'center')
-
- # According to the HTML standard, these block tags can contain
- # another tag of the same type. Furthermore, it's common
- # to actually use these tags this way.
- NESTABLE_BLOCK_TAGS = ('blockquote', 'div', 'fieldset', 'ins', 'del')
-
- # Lists can contain other lists, but there are restrictions.
- NESTABLE_LIST_TAGS = {'ol': [],
- 'ul': [],
- 'li': ['ul', 'ol'],
- 'dl': [],
- 'dd': ['dl'],
- 'dt': ['dl']}
-
- # Tables can contain other tables, but there are restrictions.
- NESTABLE_TABLE_TAGS = {'table': [],
- 'tr': ['table', 'tbody', 'tfoot', 'thead'],
- 'td': ['tr'],
- 'th': ['tr'],
- 'thead': ['table'],
- 'tbody': ['table'],
- 'tfoot': ['table'],
- }
-
- NON_NESTABLE_BLOCK_TAGS = ('address', 'form', 'p', 'pre')
-
- # If one of these tags is encountered, all tags up to the next tag of
- # this type are popped.
- RESET_NESTING_TAGS = buildTagMap(None, NESTABLE_BLOCK_TAGS, 'noscript',
- NON_NESTABLE_BLOCK_TAGS,
- NESTABLE_LIST_TAGS,
- NESTABLE_TABLE_TAGS)
-
- NESTABLE_TAGS = buildTagMap([], NESTABLE_INLINE_TAGS, NESTABLE_BLOCK_TAGS,
- NESTABLE_LIST_TAGS, NESTABLE_TABLE_TAGS)
-
- # Used to detect the charset in a META tag; see start_meta
- CHARSET_RE = re.compile("((^|;)\s*charset=)([^;]*)", re.M)
-
- def start_meta(self, attrs):
- """Beautiful Soup can detect a charset included in a META tag,
- try to convert the document to that charset, and re-parse the
- document from the beginning."""
- httpEquiv = None
- contentType = None
- contentTypeIndex = None
- tagNeedsEncodingSubstitution = False
-
- for i in range(0, len(attrs)):
- key, value = attrs[i]
- key = key.lower()
- if key == 'http-equiv':
- httpEquiv = value
- elif key == 'content':
- contentType = value
- contentTypeIndex = i
-
- if httpEquiv and contentType: # It's an interesting meta tag.
- match = self.CHARSET_RE.search(contentType)
- if match:
- if (self.declaredHTMLEncoding is not None or
- self.originalEncoding == self.fromEncoding):
- # An HTML encoding was sniffed while converting
- # the document to Unicode, or an HTML encoding was
- # sniffed during a previous pass through the
- # document, or an encoding was specified
- # explicitly and it worked. Rewrite the meta tag.
- def rewrite(match):
- return match.group(1) + "%SOUP-ENCODING%"
- newAttr = self.CHARSET_RE.sub(rewrite, contentType)
- attrs[contentTypeIndex] = (attrs[contentTypeIndex][0],
- newAttr)
- tagNeedsEncodingSubstitution = True
- else:
- # This is our first pass through the document.
- # Go through it again with the encoding information.
- newCharset = match.group(3)
- if newCharset and newCharset != self.originalEncoding:
- self.declaredHTMLEncoding = newCharset
- self._feed(self.declaredHTMLEncoding)
- raise StopParsing
- pass
- tag = self.unknown_starttag("meta", attrs)
- if tag and tagNeedsEncodingSubstitution:
- tag.containsSubstitutions = True
-
-
-class StopParsing(Exception):
- pass
-
-
-class ICantBelieveItsBeautifulSoup(BeautifulSoup):
-
- """The BeautifulSoup class is oriented towards skipping over
- common HTML errors like unclosed tags. However, sometimes it makes
- errors of its own. For instance, consider this fragment:
-
- FooBar
-
- This is perfectly valid (if bizarre) HTML. However, the
- BeautifulSoup class will implicitly close the first b tag when it
- encounters the second 'b'. It will think the author wrote
- "FooBar", and didn't close the first 'b' tag, because
- there's no real-world reason to bold something that's already
- bold. When it encounters '' it will close two more 'b'
- tags, for a grand total of three tags closed instead of two. This
- can throw off the rest of your document structure. The same is
- true of a number of other tags, listed below.
-
- It's much more common for someone to forget to close a 'b' tag
- than to actually use nested 'b' tags, and the BeautifulSoup class
- handles the common case. This class handles the not-co-common
- case: where you can't believe someone wrote what they did, but
- it's valid HTML and BeautifulSoup screwed up by assuming it
- wouldn't be."""
-
- I_CANT_BELIEVE_THEYRE_NESTABLE_INLINE_TAGS = \
- ('em', 'big', 'i', 'small', 'tt', 'abbr', 'acronym', 'strong',
- 'cite', 'code', 'dfn', 'kbd', 'samp', 'strong', 'var', 'b',
- 'big')
-
- I_CANT_BELIEVE_THEYRE_NESTABLE_BLOCK_TAGS = ('noscript',)
-
- NESTABLE_TAGS = buildTagMap([], BeautifulSoup.NESTABLE_TAGS,
- I_CANT_BELIEVE_THEYRE_NESTABLE_BLOCK_TAGS,
- I_CANT_BELIEVE_THEYRE_NESTABLE_INLINE_TAGS)
-
-
-class MinimalSoup(BeautifulSoup):
- """The MinimalSoup class is for parsing HTML that contains
- pathologically bad markup. It makes no assumptions about tag
- nesting, but it does know which tags are self-closing, that
- '
- for text, lspace, funcdecl, rspace, end_p in self._scan_chunks(input, filename):
- if end_p:
- break
- if funcdecl:
- buf.append(text)
- if re.match(r'^\$?\w+\(', funcdecl):
- buf.extend((lspace or '', stag, 'function ',
- funcdecl, "{var _buf='';", rspace or ''))
- else:
- m = re.match(r'(.+?)\((.*)\)', funcdecl)
- buf.extend((lspace or '', stag, m.group(
- 1), '=function(', m.group(2), "){var _buf='';", rspace or ''))
- else:
- self._parse_stmts(text, buf)
- buf.extend(
- (lspace or '', "return _buf;};", etag, rspace or ''))
- #
- buf.append(text)
-
- STMT_REXP = re.compile(
- r'(?:^( *)<|<)\?js(\s.*?) ?\?>([ \t]*\r?\n)?', re.M | re.S)
-
- def _scan_stmts(self, input):
- rexp = self.STMT_REXP
- pos = 0
- for m in rexp.finditer(input):
- lspace, code, rspace = m.groups()
- text = input[pos:m.start()]
- pos = m.end()
- yield text, lspace, code, rspace, False
- rest = input[pos:]
- yield rest, None, None, None, True
-
- def _parse_stmts(self, input, buf):
- if not input:
- return
- for text, lspace, code, rspace, end_p in self._scan_stmts(input):
- if end_p:
- break
- if lspace is not None and rspace is not None:
- self._parse_exprs(text, buf)
- buf.extend((lspace, code, rspace))
- else:
- if lspace:
- text += lspace
- self._parse_exprs(text, buf)
- buf.append(code)
- if rspace:
- self._parse_exprs(rspace, buf)
- if text:
- self._parse_exprs(text, buf)
-
- s = r'(?:\{[^{}]*?\}[^{}]*?)*'
- EXPR_REXP = re.compile(r'\{=(.*?)=\}|([$#])\{(.*?' + s + r')\}', re.S)
- del s
-
- def _get_expr(self, m):
- code1, ch, code2 = m.groups()
- if ch:
- code = code2
- escape_p = ch == '$'
- elif code1[0] == code1[-1] == '=':
- code = code1[1:-1]
- escape_p = False
- else:
- code = code1
- escape_p = True
- return code, escape_p
-
- def _scan_exprs(self, input):
- rexp = self.EXPR_REXP
- pos = 0
- for m in rexp.finditer(input):
- text = input[pos:m.start()]
- pos = m.end()
- code, escape_p = self._get_expr(m)
- yield text, code, escape_p, False
- rest = input[pos:]
- yield rest, None, None, True
-
- def _parse_exprs(self, input, buf):
- if not input:
- return
- buf.append("_buf+=")
- extend = buf.extend
- op = ''
- for text, code, escape_p, end_p in self._scan_exprs(input):
- if end_p:
- break
- if text:
- extend((op, self._escape_text(text)))
- op = '+'
- if code:
- extend((op, escape_p and '_E(' or '_S(', code, ')'))
- op = '+'
- rest = text
- if rest:
- extend((op, self._escape_text(rest)))
- if input.endswith("\n"):
- buf.append(";\n")
- else:
- buf.append(";")
-
- def _escape_text(self, text):
- lines = text.splitlines(True)
- fn = self._escape_str
- s = "\\\n".join(fn(line) for line in lines)
- return "".join(("'", s, "'"))
-
- def _escape_str(self, string):
- return string.replace("\\", "\\\\").replace("'", "\\'").replace("\n", r"\n")
-
-
-def _linenum(input, pos):
- return input[0:pos].count("\n") + 1
-
-
-JS_FUNC = r"""
-function _S(x){return x==null?'':x;}
-function _E(x){return x==null?'':typeof(x)!=='string'?x:x.replace(/[&<>"']/g,_EF);}
-var _ET={'&':"&",'<':"<",'>':">",'"':""","'":"'"};
-function _EF(c){return _ET[c];};
-"""[1:-1]
-JS_FUNC = escaped.EscapedStr(JS_FUNC)
-
-
-##
-# cache storages
-##
-
-class CacheStorage(object):
- """[abstract] Template object cache class (in memory and/or file)"""
-
- def __init__(self):
- self.items = {} # key: full path, value: template object
-
- def get(self, cachepath, create_template):
- """get template object. if not found, load attributes from cache file and restore template object."""
- template = self.items.get(cachepath)
- if not template:
- dct = self._load(cachepath)
- if dct:
- template = create_template()
- for k in dct:
- setattr(template, k, dct[k])
- self.items[cachepath] = template
- return template
-
- def set(self, cachepath, template):
- """set template object and save template attributes into cache file."""
- self.items[cachepath] = template
- dct = self._save_data_of(template)
- return self._store(cachepath, dct)
-
- def _save_data_of(self, template):
- return {'args': template.args, 'bytecode': template.bytecode,
- 'script': template.script, 'timestamp': template.timestamp}
-
- def unset(self, cachepath):
- """remove template object from dict and cache file."""
- self.items.pop(cachepath, None)
- return self._delete(cachepath)
-
- def clear(self):
- """remove all template objects and attributes from dict and cache file."""
- d, self.items = self.items, {}
- for k in d.iterkeys():
- self._delete(k)
- d.clear()
-
- def _load(self, cachepath):
- """(abstract) load dict object which represents template object attributes from cache file."""
- raise NotImplementedError.new(
- "%s#_load(): not implemented yet." % self.__class__.__name__)
-
- def _store(self, cachepath, template):
- """(abstract) load dict object which represents template object attributes from cache file."""
- raise NotImplementedError.new(
- "%s#_store(): not implemented yet." % self.__class__.__name__)
-
- def _delete(self, cachepath):
- """(abstract) remove template object from cache file."""
- raise NotImplementedError.new(
- "%s#_delete(): not implemented yet." % self.__class__.__name__)
-
-
-class MemoryCacheStorage(CacheStorage):
-
- def _load(self, cachepath):
- return None
-
- def _store(self, cachepath, template):
- pass
-
- def _delete(self, cachepath):
- pass
-
-
-class FileCacheStorage(CacheStorage):
-
- def _load(self, cachepath):
- if not _isfile(cachepath):
- return None
- if logger:
- logger.info("[tenjin.%s] load cache (file=%r)" %
- (self.__class__.__name__, cachepath))
- data = _read_binary_file(cachepath)
- return self._restore(data)
-
- def _store(self, cachepath, dct):
- if logger:
- logger.info("[tenjin.%s] store cache (file=%r)" %
- (self.__class__.__name__, cachepath))
- data = self._dump(dct)
- _write_binary_file(cachepath, data)
-
- def _restore(self, data):
- raise NotImplementedError(
- "%s._restore(): not implemented yet." % self.__class__.__name__)
-
- def _dump(self, dct):
- raise NotImplementedError(
- "%s._dump(): not implemented yet." % self.__class__.__name__)
-
- def _delete(self, cachepath):
- _ignore_not_found_error(lambda: os.unlink(cachepath))
-
-
-class MarshalCacheStorage(FileCacheStorage):
-
- def _restore(self, data):
- return marshal.loads(data)
-
- def _dump(self, dct):
- return marshal.dumps(dct)
-
-
-class PickleCacheStorage(FileCacheStorage):
-
- def __init__(self, *args, **kwargs):
- global pickle
- if pickle is None:
- import cPickle as pickle
- FileCacheStorage.__init__(self, *args, **kwargs)
-
- def _restore(self, data):
- return pickle.loads(data)
-
- def _dump(self, dct):
- dct.pop('bytecode', None)
- return pickle.dumps(dct)
-
-
-class TextCacheStorage(FileCacheStorage):
-
- def _restore(self, data):
- header, script = data.split("\n\n", 1)
- timestamp = encoding = args = None
- for line in header.split("\n"):
- key, val = line.split(": ", 1)
- if key == 'timestamp':
- timestamp = float(val)
- elif key == 'encoding':
- encoding = val
- elif key == 'args':
- args = val.split(', ')
- if encoding:
- script = script.decode(encoding) # binary(=str) to unicode
- return {'args': args, 'script': script, 'timestamp': timestamp}
-
- def _dump(self, dct):
- s = dct['script']
- if dct.get('encoding') and isinstance(s, unicode):
- s = s.encode(dct['encoding']) # unicode to binary(=str)
- sb = []
- sb.append("timestamp: %s\n" % dct['timestamp'])
- if dct.get('encoding'):
- sb.append("encoding: %s\n" % dct['encoding'])
- if dct.get('args') is not None:
- sb.append("args: %s\n" % ', '.join(dct['args']))
- sb.append("\n")
- sb.append(s)
- s = ''.join(sb)
- if python3:
- if isinstance(s, str):
- # unicode(=str) to binary
- s = s.encode(dct.get('encoding') or 'utf-8')
- return s
-
- def _save_data_of(self, template):
- dct = FileCacheStorage._save_data_of(self, template)
- dct['encoding'] = template.encoding
- return dct
-
-
-##
-# abstract class for data cache
-##
-class KeyValueStore(object):
-
- def get(self, key, *options):
- raise NotImplementedError(
- "%s.get(): not implemented yet." % self.__class__.__name__)
-
- def set(self, key, value, *options):
- raise NotImplementedError(
- "%s.set(): not implemented yet." % self.__class__.__name__)
-
- def delete(self, key, *options):
- raise NotImplementedError(
- "%s.del(): not implemented yet." % self.__class__.__name__)
-
- def has(self, key, *options):
- raise NotImplementedError(
- "%s.has(): not implemented yet." % self.__class__.__name__)
-
-
-##
-# memory base data cache
-##
-class MemoryBaseStore(KeyValueStore):
-
- def __init__(self):
- self.values = {}
-
- def get(self, key, original_timestamp=None):
- tupl = self.values.get(key)
- if not tupl:
- return None
- value, created_at, expires_at = tupl
- if original_timestamp is not None and created_at < original_timestamp:
- self.delete(key)
- return None
- if expires_at < _time():
- self.delete(key)
- return None
- return value
-
- def set(self, key, value, lifetime=0):
- created_at = _time()
- expires_at = lifetime and created_at + lifetime or 0
- self.values[key] = (value, created_at, expires_at)
- return True
-
- def delete(self, key):
- try:
- del self.values[key]
- return True
- except KeyError:
- return False
-
- def has(self, key):
- pair = self.values.get(key)
- if not pair:
- return False
- value, created_at, expires_at = pair
- if expires_at and expires_at < _time():
- self.delete(key)
- return False
- return True
-
-
-##
-# file base data cache
-##
-class FileBaseStore(KeyValueStore):
-
- lifetime = 604800 # = 60*60*24*7
-
- def __init__(self, root_path, encoding=None):
- if not os.path.isdir(root_path):
- raise ValueError("%r: directory not found." % (root_path, ))
- self.root_path = root_path
- if encoding is None and python3:
- encoding = 'utf-8'
- self.encoding = encoding
-
- _pat = re.compile(r'[^-.\/\w]')
-
- def filepath(self, key, _pat1=_pat):
- return os.path.join(self.root_path, _pat1.sub('_', key))
-
- def get(self, key, original_timestamp=None):
- fpath = self.filepath(key)
- # if not _isfile(fpath): return None
- stat = _ignore_not_found_error(lambda: os.stat(fpath), None)
- if stat is None:
- return None
- created_at = stat.st_ctime
- expires_at = stat.st_mtime
- if original_timestamp is not None and created_at < original_timestamp:
- self.delete(key)
- return None
- if expires_at < _time():
- self.delete(key)
- return None
- if self.encoding:
- def f(): return _read_text_file(fpath, self.encoding)
- else:
- def f(): return _read_binary_file(fpath)
- return _ignore_not_found_error(f, None)
-
- def set(self, key, value, lifetime=0):
- fpath = self.filepath(key)
- dirname = os.path.dirname(fpath)
- if not os.path.isdir(dirname):
- os.makedirs(dirname)
- now = _time()
- if isinstance(value, _unicode):
- value = value.encode(self.encoding or 'utf-8')
- _write_binary_file(fpath, value)
- expires_at = now + (lifetime or self.lifetime) # timestamp
- os.utime(fpath, (expires_at, expires_at))
- return True
-
- def delete(self, key):
- fpath = self.filepath(key)
- ret = _ignore_not_found_error(lambda: os.unlink(fpath), False)
- return ret != False
-
- def has(self, key):
- fpath = self.filepath(key)
- if not _isfile(fpath):
- return False
- if _getmtime(fpath) < _time():
- self.delete(key)
- return False
- return True
-
-
-##
-# html fragment cache helper class
-##
-class FragmentCacheHelper(object):
- """html fragment cache helper class."""
-
- lifetime = 60 # 1 minute
- prefix = None
-
- def __init__(self, store, lifetime=None, prefix=None):
- self.store = store
- if lifetime is not None:
- self.lifetime = lifetime
- if prefix is not None:
- self.prefix = prefix
-
- def not_cached(self, cache_key, lifetime=None):
- """(obsolete. use cache_as() instead of this.)
- html fragment cache helper. see document of FragmentCacheHelper class."""
- context = sys._getframe(1).f_locals['_context']
- context['_cache_key'] = cache_key
- key = self.prefix and self.prefix + cache_key or cache_key
- value = self.store.get(key)
- if value: # cached
- if logger:
- logger.debug('[tenjin.not_cached] %r: cached.' % (cache_key, ))
- context[key] = value
- return False
- else: # not cached
- if logger:
- logger.debug(
- '[tenjin.not_cached]: %r: not cached.' % (cache_key, ))
- if key in context:
- del context[key]
- if lifetime is None:
- lifetime = self.lifetime
- context['_cache_lifetime'] = lifetime
- helpers.start_capture(cache_key, _depth=2)
- return True
-
- def echo_cached(self):
- """(obsolete. use cache_as() instead of this.)
- html fragment cache helper. see document of FragmentCacheHelper class."""
- f_locals = sys._getframe(1).f_locals
- context = f_locals['_context']
- cache_key = context.pop('_cache_key')
- key = self.prefix and self.prefix + cache_key or cache_key
- if key in context: # cached
- value = context.pop(key)
- else: # not cached
- value = helpers.stop_capture(False, _depth=2)
- lifetime = context.pop('_cache_lifetime')
- self.store.set(key, value, lifetime)
- f_locals['_buf'].append(value)
-
- def functions(self):
- """(obsolete. use cache_as() instead of this.)"""
- return (self.not_cached, self.echo_cached)
-
- def cache_as(self, cache_key, lifetime=None):
- key = self.prefix and self.prefix + cache_key or cache_key
- _buf = sys._getframe(1).f_locals['_buf']
- value = self.store.get(key)
- if value:
- if logger:
- logger.debug('[tenjin.cache_as] %r: cache found.' %
- (cache_key, ))
- _buf.append(value)
- else:
- if logger:
- logger.debug(
- '[tenjin.cache_as] %r: expired or not cached yet.' % (cache_key, ))
- _buf_len = len(_buf)
- yield None
- value = ''.join(_buf[_buf_len:])
- self.store.set(key, value, lifetime)
-
-
-# you can change default store by 'tenjin.helpers.fragment_cache.store = ...'
-helpers.fragment_cache = FragmentCacheHelper(MemoryBaseStore())
-helpers.not_cached = helpers.fragment_cache.not_cached
-helpers.echo_cached = helpers.fragment_cache.echo_cached
-helpers.cache_as = helpers.fragment_cache.cache_as
-helpers.__all__.extend(('not_cached', 'echo_cached', 'cache_as'))
-
-
-##
-# helper class to find and read template
-##
-class Loader(object):
-
- def exists(self, filepath):
- raise NotImplementedError(
- "%s.exists(): not implemented yet." % self.__class__.__name__)
-
- def find(self, filename, dirs=None):
- #: if dirs provided then search template file from it.
- if dirs:
- for dirname in dirs:
- filepath = os.path.join(dirname, filename)
- if self.exists(filepath):
- return filepath
- #: if dirs not provided then just return filename if file exists.
- else:
- if self.exists(filename):
- return filename
- #: if file not found then return None.
- return None
-
- def abspath(self, filename):
- raise NotImplementedError(
- "%s.abspath(): not implemented yet." % self.__class__.__name__)
-
- def timestamp(self, filepath):
- raise NotImplementedError(
- "%s.timestamp(): not implemented yet." % self.__class__.__name__)
-
- def load(self, filepath):
- raise NotImplementedError(
- "%s.timestamp(): not implemented yet." % self.__class__.__name__)
-
-
-##
-# helper class to find and read files
-##
-class FileSystemLoader(Loader):
-
- def exists(self, filepath):
- #: return True if filepath exists as a file.
- return os.path.isfile(filepath)
-
- def abspath(self, filepath):
- #: return full-path of filepath
- return os.path.abspath(filepath)
-
- def timestamp(self, filepath):
- #: return mtime of file
- return _getmtime(filepath)
-
- def load(self, filepath):
- #: if file exists, return file content and mtime
- def f():
- mtime = _getmtime(filepath)
- input = _read_template_file(filepath)
- mtime2 = _getmtime(filepath)
- if mtime != mtime2:
- mtime = mtime2
- input = _read_template_file(filepath)
- mtime2 = _getmtime(filepath)
- if mtime != mtime2:
- if logger:
- logger.warn(
- "[tenjin] %s.load(): timestamp is changed while reading file." % self.__class__.__name__)
- return input, mtime
- #: if file not exist, return None
- return _ignore_not_found_error(f)
-
-
-##
-##
-##
-class TemplateNotFoundError(Exception):
- pass
-
-
-##
-# template engine class
-##
-
-class Engine(object):
- """Template Engine class.
- See User's Guide and examples for details.
- http://www.kuwata-lab.com/tenjin/pytenjin-users-guide.html
- http://www.kuwata-lab.com/tenjin/pytenjin-examples.html
- """
-
- # default value of attributes
- prefix = ''
- postfix = ''
- layout = None
- templateclass = Template
- path = None
- cache = TextCacheStorage() # save converted Python code into text file
- lang = None
- loader = FileSystemLoader()
- preprocess = False
- preprocessorclass = Preprocessor
- timestamp_interval = 1 # seconds
-
- def __init__(self, prefix=None, postfix=None, layout=None, path=None, cache=True, preprocess=None, templateclass=None, preprocessorclass=None, lang=None, loader=None, pp=None, **kwargs):
- """Initializer of Engine class.
-
- prefix:str (='')
- Prefix string used to convert template short name to template filename.
- postfix:str (='')
- Postfix string used to convert template short name to template filename.
- layout:str (=None)
- Default layout template name.
- path:list of str(=None)
- List of directory names which contain template files.
- cache:bool or CacheStorage instance (=True)
- Cache storage object to store converted python code.
- If True, default cache storage (=Engine.cache) is used (if it is None
- then create MarshalCacheStorage object for each engine object).
- If False, no cache storage is used nor no cache files are created.
- preprocess:bool(=False)
- Activate preprocessing or not.
- templateclass:class (=Template)
- Template class which engine creates automatically.
- lang:str (=None)
- Language name such as 'en', 'fr', 'ja', and so on. If you specify
- this, cache file path will be 'inex.html.en.cache' for example.
- pp:list (=None)
- List of preprocessor object which is callable and manipulates template content.
- kwargs:dict
- Options for Template class constructor.
- See document of Template.__init__() for details.
- """
- if prefix:
- self.prefix = prefix
- if postfix:
- self.postfix = postfix
- if layout:
- self.layout = layout
- if templateclass:
- self.templateclass = templateclass
- if preprocessorclass:
- self.preprocessorclass = preprocessorclass
- if path is not None:
- self.path = path
- if lang is not None:
- self.lang = lang
- if loader is not None:
- self.loader = loader
- if preprocess is not None:
- self.preprocess = preprocess
- if pp is None:
- pp = []
- elif isinstance(pp, list):
- pass
- elif isinstance(pp, tuple):
- pp = list(pp)
- else:
- raise TypeError("'pp' expected to be a list but got %r." % (pp,))
- self.pp = pp
- if preprocess:
- self.pp.append(TemplatePreprocessor(self.preprocessorclass))
- self.kwargs = kwargs
- self.encoding = kwargs.get('encoding')
- self._filepaths = {} # template_name => relative path and absolute path
- self._added_templates = {} # templates added by add_template()
- #self.cache = cache
- self._set_cache_storage(cache)
-
- def _set_cache_storage(self, cache):
- if cache is True:
- if not self.cache:
- self.cache = MarshalCacheStorage()
- elif cache is None:
- pass
- elif cache is False:
- self.cache = None
- elif isinstance(cache, CacheStorage):
- self.cache = cache
- else:
- raise ValueError("%r: invalid cache object." % (cache, ))
-
- def cachename(self, filepath):
- #: if lang is provided then add it to cache filename.
- if self.lang:
- return '%s.%s.cache' % (filepath, self.lang)
- #: return cache file name.
- else:
- return filepath + '.cache'
-
- def to_filename(self, template_name):
- """Convert template short name into filename.
- ex.
- >>> engine = tenjin.Engine(prefix='user_', postfix='.pyhtml')
- >>> engine.to_filename(':list')
- 'user_list.pyhtml'
- >>> engine.to_filename('list')
- 'list'
- """
- #: if template_name starts with ':', add prefix and postfix to it.
- if template_name[0] == ':':
- return self.prefix + template_name[1:] + self.postfix
- #: if template_name doesn't start with ':', just return it.
- return template_name
-
- def _create_template(self, input=None, filepath=None, _context=None, _globals=None):
- #: if input is not specified then just create empty template object.
- template = self.templateclass(None, **self.kwargs)
- #: if input is specified then create template object and return it.
- if input:
- template.convert(input, filepath)
- return template
-
- def _preprocess(self, input, filepath, _context, _globals):
- #if _context is None: _context = {}
- #if _globals is None: _globals = sys._getframe(3).f_globals
- #: preprocess template and return result
- #preprocessor = self.preprocessorclass(filepath, input=input)
- # return preprocessor.render(_context, globals=_globals)
- #: preprocesses input with _context and returns result.
- if '_engine' not in _context:
- self.hook_context(_context)
- for pp in self.pp:
- input = pp.__call__(input, filename=filepath,
- context=_context, globals=_globals)
- return input
-
- def add_template(self, template):
- self._added_templates[template.filename] = template
-
- def _get_template_from_cache(self, cachepath, filepath):
- #: if template not found in cache, return None
- template = self.cache.get(cachepath, self.templateclass)
- if not template:
- return None
- assert template.timestamp is not None
- #: if checked within a sec, skip timestamp check.
- now = _time()
- last_checked = getattr(template, '_last_checked_at', None)
- if last_checked and now < last_checked + self.timestamp_interval:
- # if logger: logger.trace('[tenjin.%s] timestamp check skipped (%f < %f + %f)' % \
- # (self.__class__.__name__, now, template._last_checked_at, self.timestamp_interval))
- return template
- #: if timestamp of template objectis same as file, return it.
- if template.timestamp == self.loader.timestamp(filepath):
- template._last_checked_at = now
- return template
- #: if timestamp of template object is different from file, clear it
- # cache._delete(cachepath)
- if logger:
- logger.info("[tenjin.%s] cache expired (filepath=%r)" %
- (self.__class__.__name__, filepath))
- return None
-
- def get_template(self, template_name, _context=None, _globals=None):
- """Return template object.
- If template object has not registered, template engine creates
- and registers template object automatically.
- """
- #: accept template_name such as ':index'.
- filename = self.to_filename(template_name)
- #: if template object is added by add_template(), return it.
- if filename in self._added_templates:
- return self._added_templates[filename]
- #: get filepath and fullpath of template
- pair = self._filepaths.get(filename)
- if pair:
- filepath, fullpath = pair
- else:
- #: if template file is not found then raise TemplateNotFoundError.
- filepath = self.loader.find(filename, self.path)
- if not filepath:
- raise TemplateNotFoundError(
- '%s: filename not found (path=%r).' % (filename, self.path))
- #
- fullpath = self.loader.abspath(filepath)
- self._filepaths[filename] = (filepath, fullpath)
- #: use full path as base of cache file path
- cachepath = self.cachename(fullpath)
- #: get template object from cache
- cache = self.cache
- template = cache and self._get_template_from_cache(
- cachepath, filepath) or None
- #: if template object is not found in cache or is expired...
- if not template:
- ret = self.loader.load(filepath)
- if not ret:
- raise TemplateNotFoundError(
- "%r: template not found." % filepath)
- input, timestamp = ret
- if self.pp: # required for preprocessing
- if _context is None:
- _context = {}
- if _globals is None:
- _globals = sys._getframe(1).f_globals
- input = self._preprocess(input, filepath, _context, _globals)
- #: create template object.
- template = self._create_template(
- input, filepath, _context, _globals)
- #: set timestamp and filename of template object.
- template.timestamp = timestamp
- template._last_checked_at = _time()
- #: save template object into cache.
- if cache:
- if not template.bytecode:
- #: ignores syntax error when compiling.
- try:
- template.compile()
- except SyntaxError:
- pass
- cache.set(cachepath, template)
- # else:
- # template.compile()
- #:
- template.filename = filepath
- return template
-
- def include(self, template_name, append_to_buf=True, **kwargs):
- """Evaluate template using current local variables as context.
-
- template_name:str
- Filename (ex. 'user_list.pyhtml') or short name (ex. ':list') of template.
- append_to_buf:boolean (=True)
- If True then append output into _buf and return None,
- else return stirng output.
-
- ex.
-
- #{include('file.pyhtml', False)}
-
- """
- #: get local and global vars of caller.
- frame = sys._getframe(1)
- locals = frame.f_locals
- globals = frame.f_globals
- #: get _context from caller's local vars.
- assert '_context' in locals
- context = locals['_context']
- #: if kwargs specified then add them into context.
- if kwargs:
- context.update(kwargs)
- #: get template object with context data and global vars.
- # (context and globals are passed to get_template() only for preprocessing.)
- template = self.get_template(template_name, context, globals)
- #: if append_to_buf is true then add output to _buf.
- #: if append_to_buf is false then don't add output to _buf.
- if append_to_buf:
- _buf = locals['_buf']
- else:
- _buf = None
- #: render template and return output.
- s = template.render(context, globals, _buf=_buf)
- #: kwargs are removed from context data.
- if kwargs:
- for k in kwargs:
- del context[k]
- return s
-
- def render(self, template_name, context=None, globals=None, layout=True):
- """Evaluate template with layout file and return result of evaluation.
-
- template_name:str
- Filename (ex. 'user_list.pyhtml') or short name (ex. ':list') of template.
- context:dict (=None)
- Context object to evaluate. If None then new dict is used.
- globals:dict (=None)
- Global context to evaluate. If None then globals() is used.
- layout:str or Bool(=True)
- If True, the default layout name specified in constructor is used.
- If False, no layout template is used.
- If str, it is regarded as layout template name.
-
- If temlate object related with the 'template_name' argument is not exist,
- engine generates a template object and register it automatically.
- """
- if context is None:
- context = {}
- if globals is None:
- globals = sys._getframe(1).f_globals
- self.hook_context(context)
- while True:
- # context and globals are passed to get_template() only for preprocessing
- template = self.get_template(template_name, context, globals)
- content = template.render(context, globals)
- layout = context.pop('_layout', layout)
- if layout is True or layout is None:
- layout = self.layout
- if not layout:
- break
- template_name = layout
- layout = False
- context['_content'] = content
- context.pop('_content', None)
- return content
-
- def hook_context(self, context):
- #: add engine itself into context data.
- context['_engine'] = self
- #context['render'] = self.render
- #: add include() method into context data.
- context['include'] = self.include
-
-
-##
-# safe template and engine
-##
-
-class SafeTemplate(Template):
- """Uses 'to_escaped()' instead of 'escape()'.
- '#{...}' is not allowed with this class. Use '[==...==]' instead.
- """
-
- tostrfunc = 'to_str'
- escapefunc = 'to_escaped'
-
- def get_expr_and_flags(self, match):
- return _get_expr_and_flags(match, "#{%s}: '#{}' is not allowed with SafeTemplate.")
-
-
-class SafePreprocessor(Preprocessor):
-
- tostrfunc = 'to_str'
- escapefunc = 'to_escaped'
-
- def get_expr_and_flags(self, match):
- return _get_expr_and_flags(match, "#{{%s}}: '#{{}}' is not allowed with SafePreprocessor.")
-
-
-def _get_expr_and_flags(match, errmsg):
- expr1, expr2, expr3, expr4 = match.groups()
- if expr1 is not None:
- raise TemplateSyntaxError(errmsg % match.group(1))
- if expr2 is not None:
- return expr2, (True, False) # #{...} : call escape, not to_str
- if expr3 is not None:
- return expr3, (False, True) # [==...==] : not escape, call to_str
- if expr4 is not None:
- return expr4, (True, False) # [=...=] : call escape, not to_str
-
-
-class SafeEngine(Engine):
-
- templateclass = SafeTemplate
- preprocessorclass = SafePreprocessor
-
-
-##
-# for Google App Engine
-# (should separate into individual file or module?)
-##
-
-def _dummy():
- global memcache, _tenjin
- memcache = _tenjin = None # lazy import of google.appengine.api.memcache
- global GaeMemcacheCacheStorage, GaeMemcacheStore, init
-
- class GaeMemcacheCacheStorage(CacheStorage):
-
- lifetime = 0 # 0 means unlimited
-
- def __init__(self, lifetime=None, namespace=None):
- CacheStorage.__init__(self)
- if lifetime is not None:
- self.lifetime = lifetime
- self.namespace = namespace
-
- def _load(self, cachepath):
- key = cachepath
- if _tenjin.logger:
- _tenjin.logger.info(
- "[tenjin.gae.GaeMemcacheCacheStorage] load cache (key=%r)" % (key, ))
- return memcache.get(key, namespace=self.namespace)
-
- def _store(self, cachepath, dct):
- dct.pop('bytecode', None)
- key = cachepath
- if _tenjin.logger:
- _tenjin.logger.info(
- "[tenjin.gae.GaeMemcacheCacheStorage] store cache (key=%r)" % (key, ))
- ret = memcache.set(key, dct, self.lifetime,
- namespace=self.namespace)
- if not ret:
- if _tenjin.logger:
- _tenjin.logger.info(
- "[tenjin.gae.GaeMemcacheCacheStorage] failed to store cache (key=%r)" % (key, ))
-
- def _delete(self, cachepath):
- key = cachepath
- memcache.delete(key, namespace=self.namespace)
-
- class GaeMemcacheStore(KeyValueStore):
-
- lifetime = 0
-
- def __init__(self, lifetime=None, namespace=None):
- if lifetime is not None:
- self.lifetime = lifetime
- self.namespace = namespace
-
- def get(self, key):
- return memcache.get(key, namespace=self.namespace)
-
- def set(self, key, value, lifetime=None):
- if lifetime is None:
- lifetime = self.lifetime
- if memcache.set(key, value, lifetime, namespace=self.namespace):
- return True
- else:
- if _tenjin.logger:
- _tenjin.logger.info(
- "[tenjin.gae.GaeMemcacheStore] failed to set (key=%r)" % (key, ))
- return False
-
- def delete(self, key):
- return memcache.delete(key, namespace=self.namespace)
-
- def has(self, key):
- if memcache.add(key, 'dummy', namespace=self.namespace):
- memcache.delete(key, namespace=self.namespace)
- return False
- else:
- return True
-
- def init():
- global memcache, _tenjin
- if not memcache:
- from google.appengine.api import memcache
- if not _tenjin:
- import tenjin as _tenjin
- # avoid cache confliction between versions
- ver = os.environ.get('CURRENT_VERSION_ID', '1.1') # .split('.')[0]
- Engine.cache = GaeMemcacheCacheStorage(namespace=ver)
- # set fragment cache store
- helpers.fragment_cache.store = GaeMemcacheStore(namespace=ver)
- helpers.fragment_cache.lifetime = 60 # 1 minute
- helpers.fragment_cache.prefix = 'fragment.'
-
-
-gae = create_module('tenjin.gae', _dummy,
- os=os, helpers=helpers, Engine=Engine,
- CacheStorage=CacheStorage, KeyValueStore=KeyValueStore)
-
-
-del _dummy
diff --git a/cgi/weabot.py b/cgi/weabot.py
index 720916d..636eb02 100755
--- a/cgi/weabot.py
+++ b/cgi/weabot.py
@@ -23,7 +23,7 @@ from formatting import *
from post import *
from img import *
-__version__ = "0.10.0"
+__version__ = "0.10.5"
# Set to True to disable weabot's exception routing and enable profiling
_DEBUG = False
@@ -35,7 +35,7 @@ class weabot(object):
def __init__(self, environ, start_response):
global _DEBUG
- logging.basicConfig(filename='weabot.log', format='%(asctime)s %(levelname)s %(message)s', level=logging.DEBUG)
+ logging.basicConfig(filename='weabot.log', format='%(asctime)s %(levelname)s %(message)s', level=logging.INFO)
self.environ = environ
if self.environ["PATH_INFO"].startswith("/weabot.py/"):
@@ -85,7 +85,7 @@ class weabot(object):
def error(self, message):
board = Settings._.BOARD
if board:
- if board['board_type'] == '1':
+ if board['board_type'] == 1:
info = {}
info['host'] = self.environ["REMOTE_ADDR"]
info['name'] = self.formdata.get('fielda', '')
@@ -265,7 +265,7 @@ class weabot(object):
if Settings.ENABLE_BANS and addressIsBanned(self.environ['REMOTE_ADDR'], board["dir"], blind_only=True):
raise UserError('' % board["dir"])
- if len(path_split) > 4 and path_split[4] and board['board_type'] == '1':
+ if len(path_split) > 4 and path_split[4] and board['board_type'] == 1:
self.output = dynamicRead(int(path_split[3]), path_split[4], True)
elif board['board_type'] == 1:
self.output = threadPage(0, True, int(path_split[3]))
@@ -329,12 +329,12 @@ class weabot(object):
self.output += '... ' % url
elif path_split[1] == "banned":
OpenDb()
- bans = FetchAll("SELECT * FROM `bans` WHERE INET6_ATON('"+self.environ["REMOTE_ADDR"]+"') BETWEEN `ipstart` AND `ipend`")
+ bans = FetchAll("SELECT * FROM `bans` WHERE INET6_ATON(%s) BETWEEN `ipstart` AND `ipend`", (self.environ["REMOTE_ADDR"],))
if bans:
for ban in bans:
if ban["boards"]:
- boards = pickle.loads(ban["boards"])
- if ban["boards"] or path_split[2] in boards:
+ boards = str2boards(ban["boards"])
+ if not ban["boards"] or path_split[2] in boards:
caught = True
if ban["boards"]:
boards_str = '/' + '/, /'.join(boards) + '/'
@@ -592,7 +592,7 @@ class weabot(object):
# make ID hash
if board["useid"]:
post["timestamp_formatted"] += ' ID:' + iphash(ip, post, tim, board["useid"], mobile,
- self.environ["HTTP_USER_AGENT"], cap_id, hide_end, (board["countrycode"] in ['1', '2']))
+ self.environ["HTTP_USER_AGENT"], cap_id, hide_end, (board["countrycode"] in [1, 2]))
# use for future file checks
xfile = (file is not None or oek_file)
@@ -793,7 +793,13 @@ class weabot(object):
postid = post.insert()
# delete threads that have crossed last page
- trimThreads()
+ trimmed = trimThreads()
+
+ # let's stop here if the thread we posted in got trimmed
+ if post["parentid"] and post["parentid"] in trimmed:
+ regenerateFrontPages()
+ regenerateHome()
+ raise UserError("El hilo en el que publicaste ya fue eliminado.")
# fix null references when creating thread
if board["board_type"] == 1 and not post["parentid"]:
@@ -947,8 +953,8 @@ class weabot(object):
raise UserError(_("You're banned."))
# check if post exists
- post = FetchOne("SELECT `id`, `parentid`, `ip` FROM `posts` WHERE `id` = '%s' AND `boardid` = '%s'" % (
- _mysql.escape_string(str(postid)), _mysql.escape_string(board['id'])))
+ post = FetchOne("SELECT `id`, `parentid`, `ip` FROM `posts` WHERE `id` = %s AND `boardid` = %s",
+ (postid, board['id']))
if not post:
raise UserError(_("Post doesn't exist."))
@@ -963,13 +969,12 @@ class weabot(object):
# insert report
t = time.time()
- message = cgi.escape(self.formdata["reason"]).strip()[0:8000]
+ message = html.escape(self.formdata["reason"]).strip()[0:800]
message = message.replace("\n", "
")
UpdateDb("INSERT INTO `reports` (board, postid, parentid, link, ip, reason, repip, timestamp, timestamp_formatted) " +
- "VALUES ('%s', '%s', '%s', '%s', '%s', '%s', INET6_ATON('%s'), '%s', '%s')" % (
- board["dir"], post['id'], post['parentid'], link, post['ip'], _mysql.escape_string(message),
- _mysql.escape_string(self.environ["REMOTE_ADDR"]), str(t), formatTimestamp(t)))
+ "VALUES (%s, %s, %s, %s, %s, %s, INET6_ATON(%s), %s, %s)",
+ (board["dir"], post['id'], post['parentid'], link, post['ip'], message, self.environ["REMOTE_ADDR"], t, formatTimestamp(t)))
self.output = renderTemplate("report.html", {'finished': True})
def stats(self):
--
cgit v1.2.1-18-gbd029
|