rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
return self.evaluateNot (expr[4:].lstrip()) | res = self.evaluateNot (expr[4:].lstrip()) | def evaluate (self, expr, originalAtts = None): # Returns a ContextVariable self.log.debug ("Evaluating %s" % expr) if (originalAtts is not None): # Call from outside self.globals['attrs'] = ContextVariable(originalAtts) # Supports path, exists, nocall, not, and string expr = expr.strip () if expr.startswith ('path:')... |
return self.evaluateString (expr[7:].lstrip()) | res = self.evaluateString (expr[7:].lstrip()) | def evaluate (self, expr, originalAtts = None): # Returns a ContextVariable self.log.debug ("Evaluating %s" % expr) if (originalAtts is not None): # Call from outside self.globals['attrs'] = ContextVariable(originalAtts) # Supports path, exists, nocall, not, and string expr = expr.strip () if expr.startswith ('path:')... |
return self.evaluatePython (expr[7:].lstrip()) | res = self.evaluatePython (expr[7:].lstrip()) | def evaluate (self, expr, originalAtts = None): # Returns a ContextVariable self.log.debug ("Evaluating %s" % expr) if (originalAtts is not None): # Call from outside self.globals['attrs'] = ContextVariable(originalAtts) # Supports path, exists, nocall, not, and string expr = expr.strip () if expr.startswith ('path:')... |
return self.evaluatePath (expr) | res = self.evaluatePath (expr) self.log.debug("... result %s", str(res)) return res | def evaluate (self, expr, originalAtts = None): # Returns a ContextVariable self.log.debug ("Evaluating %s" % expr) if (originalAtts is not None): # Call from outside self.globals['attrs'] = ContextVariable(originalAtts) # Supports path, exists, nocall, not, and string expr = expr.strip () if expr.startswith ('path:')... |
def finish(self, data, **attrs): names = data.keys() for name in names: for expr in self.delete: if expr.search(name): del data[name] for key,val in self.add.items(): data[key] = val debug(HURT_ME_PLENTY, "Headers\n", data) return data | def filter(self, data, **attrs): headers = data.keys()[:] for header in headers: for name in self.delete: if header.find(name) != -1: del data[header] for key,val in self.add.items(): data[key] = val debug(HURT_ME_PLENTY, "Headers\n", data) return data | |
if attrs: self.data += " " for key,val in attrs.items(): self.data += "%s=\"%s\"" % (key, cgi.escape(val, True)) | for key,val in attrs.items(): self.data += " %s=\"%s\"" % (key, cgi.escape(val, True)) | def unknown_starttag (self, tag, attributes): attrs = {} for key,val in attributes: attrs[key] = val msgid = attrs.get('i18n:translate', None) if msgid == '': if self.tag: raise Exception, "nested i18n:translate is unsupported" self.tag = tag self.data = "" elif msgid is not None: if self.tag: raise Exception, "nested ... |
tc, self.nameserver, self.hostname) | response, self.nameserver, self.hostname) | def process_read (self): if not self.callback: self.close() # Assume that the entire answer comes in one packet if self.tcp: if len(self.recv_buffer) < 2: return header = self.recv_buffer[:2] (l,) = struct.unpack("!H", header) if len(self.recv_buffer) < 2+l: return self.read(2) # header wire = self.read(l) try: self.so... |
if self.hostname[-4:] in ('.com','.net') and \ '64.94.110.11' in ip_addrs: callback(self.hostname, DnsResponse('error', 'not found')) else: callback(self.hostname, DnsResponse('found', ip_addrs)) | callback(self.hostname, DnsResponse('found', ip_addrs)) | def process_read (self): if not self.callback: self.close() # Assume that the entire answer comes in one packet if self.tcp: if len(self.recv_buffer) < 2: return header = self.recv_buffer[:2] (l,) = struct.unpack("!H", header) if len(self.recv_buffer) < 2+l: return self.read(2) # header wire = self.read(l) try: self.so... |
def __init__ (self): """initalize filter delete/add lists""" super(Header, self).__init__() self.delete = { | def get_attrs (self, url, headers): """configure header rules to add/delete""" d = super(Header, self).get_attrs(url, headers) delete = { | def __init__ (self): """initalize filter delete/add lists""" super(Header, self).__init__() self.delete = { wc.filter.FILTER_REQUEST_HEADER: [], wc.filter.FILTER_RESPONSE_HEADER: [], } self.add = { wc.filter.FILTER_REQUEST_HEADER: [], wc.filter.FILTER_RESPONSE_HEADER: [], } |
self.add = { | add = { | def __init__ (self): """initalize filter delete/add lists""" super(Header, self).__init__() self.delete = { wc.filter.FILTER_REQUEST_HEADER: [], wc.filter.FILTER_RESPONSE_HEADER: [], } self.add = { wc.filter.FILTER_REQUEST_HEADER: [], wc.filter.FILTER_RESPONSE_HEADER: [], } |
def addrule (self, rule): """add given rule to filter, filling header delete/add lists""" super(Header, self).addrule(rule) if not rule.name: return if not rule.value: matcher = re.compile(rule.name, re.I).match if rule.filterstage in ('both', 'request'): self.delete[wc.filter.FILTER_REQUEST_HEADER].append(matcher)... | for rule in self.rules: if not rule.appliesTo(url) or not rule.name: continue if not rule.value: matcher = re.compile(rule.name, re.I).match if rule.filterstage in ('both', 'request'): delete[wc.filter.FILTER_REQUEST_HEADER].append(matcher) if rule.filterstage in ('both', 'response'): delete[wc.filter.FILTER_RESPON... | def __init__ (self): """initalize filter delete/add lists""" super(Header, self).__init__() self.delete = { wc.filter.FILTER_REQUEST_HEADER: [], wc.filter.FILTER_RESPONSE_HEADER: [], } self.add = { wc.filter.FILTER_REQUEST_HEADER: [], wc.filter.FILTER_RESPONSE_HEADER: [], } |
warn(PROXY, 'read buffer full') | warn(PROXY, '%s read buffer full', str(self)) | def handle_read (self): if not self.connected: # It's been closed (presumably recently) return |
return len(self.send_buffer) | return self.send_buffer | def writable (self): return len(self.send_buffer) |
config['allowedhostset'] = ip.hosts2map(config['allowedhosts']) | config['allowedhostset'] = _hosts2map(config['allowedhosts']) | def _form_addallowed (host): if host not in config['allowedhosts']: config['allowedhosts'].append(host) config['allowedhostset'] = ip.hosts2map(config['allowedhosts']) info['addallowed'] = True config.write_proxyconf() |
config['allowedhostset'] = ip.hosts2map(config['allowedhosts']) | config['allowedhostset'] = _hosts2map(config['allowedhosts']) | def _form_delallowed (form): removed = 0 for host in _getlist(form, 'allowedhosts'): if host in config['allowedhosts']: config['allowedhosts'].remove(host) removed += 1 if removed > 0: config['allowedhostset'] = ip.hosts2map(config['allowedhosts']) config.write_proxyconf() info['delallowed'] = True |
def _main (fname): import hotshot.stats stats = hotshot.stats.load(fname) stats.strip_dirs() stats.sort_stats('time', 'calls') stats.print_stats(25) | import sys import os import wc _profile = "webcleaner.prof" def _main (filename): """ Print profiling data and exit. """ if not wc.HasPstats: print >>sys.stderr, "The `pstats' Python module is not installed." sys.exit(1) if not os.path.isfile(filename): print >>sys.stderr, "Could not find regular file %r." % filename... | def _main (fname): import hotshot.stats stats = hotshot.stats.load(fname) stats.strip_dirs() stats.sort_stats('time', 'calls') stats.print_stats(25) |
import sys | def _main (fname): import hotshot.stats stats = hotshot.stats.load(fname) stats.strip_dirs() stats.sort_stats('time', 'calls') stats.print_stats(25) | |
_main("filter.prof") | _main(_profile) | def _main (fname): import hotshot.stats stats = hotshot.stats.load(fname) stats.strip_dirs() stats.sort_stats('time', 'calls') stats.print_stats(25) |
scripts = ['webcleanerconf', 'wcheaders'], | scripts = ['webcleanerconf', 'wcheaders'] | def create_batch_file(self, directory, data, filename): filename = os.path.join(directory, filename) # write the batch file util.execute(write_file, (filename, data), "creating %s" % filename, self.verbose>=1, self.dry_run) |
scripts = ['webcleaner', 'webcleanerconf', 'wcheaders'], | scripts = ['webcleaner', 'webcleanerconf', 'wcheaders'] | def create_batch_file(self, directory, data, filename): filename = os.path.join(directory, filename) # write the batch file util.execute(write_file, (filename, data), "creating %s" % filename, self.verbose>=1, self.dry_run) |
def is_valid_bitmask (mask): """Return True if given mask is a valid network bitmask""" return 1 <= mask <= 32 | def is_valid_cidrmask (mask): """check if given mask is a valid network bitmask in CIDR notation""" return 0 <= mask <= 32 | def is_valid_bitmask (mask): """Return True if given mask is a valid network bitmask""" return 1 <= mask <= 32 |
def suffix2mask (n): "return a mask of n bits as a long integer" return (1L << (32 - n)) - 1 def mask2suffix (mask): """return suff for given bit mask""" return 32 - int(math.log(mask+1, 2)) def dq2mask (ip): | def cidr2mask (n): "return a mask where the n left-most of 32 bits are set" return ((1L << n) - 1) << (32-n) def netmask2mask (ip): | def suffix2mask (n): "return a mask of n bits as a long integer" return (1L << (32 - n)) - 1 |
n = dq2num(ip) return -((-n+1) | n) | return dq2num(ip) | def dq2mask (ip): "return a mask of bits as a long integer" n = dq2num(ip) return -((-n+1) | n) |
n = dq2num(ip) net = n - (n & mask) return (net, mask) def dq_in_net (n, net, mask): """return True iff numerical ip n is in given net with mask. (net,mask) must be returned previously by ip2net""" m = n - (n & mask) return m == net | return dq2num(ip) & mask def dq_in_net (n, mask): """return True iff numerical ip n is in given network""" return (n & mask) == mask | def dq2net (ip, mask): "return a tuple (network ip, network mask) for given ip and mask" n = dq2num(ip) net = n - (n & mask) return (net, mask) |
for net, mask in nets: if dq_in_net(n, net, mask): | for net in nets: if dq_in_net(n, net): | def host_in_set (ip, hosts, nets): """return True if given ip is in host or network list""" if ip in hosts: return True if is_valid_ipv4(ip): n = dq2num(ip) for net, mask in nets: if dq_in_net(n, net, mask): return True return False |
if _host_bitmask_re.match(host): | if _host_cidrmask_re.match(host): | def hosts2map (hosts): """return a set of named hosts, and a list of subnets (host/netmask adresses). Only IPv4 host/netmasks are supported. """ hostset = sets.Set() nets = [] for host in hosts: if _host_bitmask_re.match(host): host, mask = host.split("/") mask = int(mask) if not is_valid_bitmask(mask): wc.log.error(wc... |
if not is_valid_bitmask(mask): wc.log.error(wc.LOG_NET, "bitmask %d is not a valid network mask", mask) | if not is_valid_cidrmask(mask): wc.log.error(wc.LOG_NET, "CIDR mask %d is not a valid network mask", mask) | def hosts2map (hosts): """return a set of named hosts, and a list of subnets (host/netmask adresses). Only IPv4 host/netmasks are supported. """ hostset = sets.Set() nets = [] for host in hosts: if _host_bitmask_re.match(host): host, mask = host.split("/") mask = int(mask) if not is_valid_bitmask(mask): wc.log.error(wc... |
nets.append(dq2net(host, suffix2mask(mask))) | nets.append(dq2net(host, cidr2mask(mask))) | def hosts2map (hosts): """return a set of named hosts, and a list of subnets (host/netmask adresses). Only IPv4 host/netmasks are supported. """ hostset = sets.Set() nets = [] for host in hosts: if _host_bitmask_re.match(host): host, mask = host.split("/") mask = int(mask) if not is_valid_bitmask(mask): wc.log.error(wc... |
nets.append(dq2net(host, dq2mask(mask))) | nets.append(dq2net(host, netmask2mask(mask))) | def hosts2map (hosts): """return a set of named hosts, and a list of subnets (host/netmask adresses). Only IPv4 host/netmasks are supported. """ hostset = sets.Set() nets = [] for host in hosts: if _host_bitmask_re.match(host): host, mask = host.split("/") mask = int(mask) if not is_valid_bitmask(mask): wc.log.error(wc... |
s = """<h1>bla</h1>""" for c in s: p.feed(c) | p.feed("""<a><t""") p.feed("""r>""") | def _broken (): p = HtmlPrinter() s = """<h1>bla</h1>""" for c in s: p.feed(c) p.flush() |
if why==(4,'Interrupted system call'): | if why.args == (4, 'Interrupted system call'): | def proxy_poll(timeout=0.0): smap = asyncore.socket_map if smap: r = filter(lambda x: x.readable(), smap.values()) w = filter(lambda x: x.writable(), smap.values()) e = smap.values() try: (r,w,e) = select.select(r,w,e, timeout) except select.error, why: debug(BRING_IT_ON, why) if why==(4,'Interrupted system call'): # t... |
self.decoders.append(wc.proxy.UnchunkStream.UnchunkStream()) | self.decoders.append( wc.proxy.decoders.UnchunkStream.UnchunkStream()) | def process_headers (self): """read and filter client request headers""" # Two newlines ends headers i = self.recv_buffer.find('\r\n\r\n') if i < 0: return i += 4 # Skip over newline terminator # the first 2 chars are the newline of request fp = StringIO.StringIO(self.read(i)[2:]) msg = wc.proxy.Headers.WcMessage(fp) #... |
return result.rstrip().lstrip('\x08').replace(' \x08', '') | result = result.lstrip('\x08').strip().replace(' \x08', '') return result | def classify (self, f): if not self.entries: raise StandardError("Not initialised properly") # Are we still looking for the ruleset to apply or are we in a rule found_rule = False # If we failed part of the rule there is no point looking for # higher level subrule allow_next = 0 # String provided by the successfull rul... |
attrs = wc.filter.get_filterattrs(fname, [wc.filter.FILTER_RESPONSE_MODIFY], | attrs = wc.filter.get_filterattrs(fname, "127.0.0.1", [wc.filter.STAGE_RESPONSE_MODIFY], | def _main (): """USAGE: test/run.sh test/filterfile.py <config dir> <.html file>""" if len(sys.argv)!=3: print _main.__doc__ sys.exit(1) confdir = sys.argv[1] fname = sys.argv[2] if fname=="-": f = sys.stdin else: f = file(fname) logfile = os.path.join(confdir, "logging.conf") wc.initlog(logfile, wc.Name, filelogs=Fals... |
filtered += wc.filter.applyfilter(wc.filter.FILTER_RESPONSE_MODIFY, data, 'filter', attrs) | filtered += wc.filter.applyfilter( wc.filter.STAGE_RESPONSE_MODIFY, data, 'filter', attrs) | def _main (): """USAGE: test/run.sh test/filterfile.py <config dir> <.html file>""" if len(sys.argv)!=3: print _main.__doc__ sys.exit(1) confdir = sys.argv[1] fname = sys.argv[2] if fname=="-": f = sys.stdin else: f = file(fname) logfile = os.path.join(confdir, "logging.conf") wc.initlog(logfile, wc.Name, filelogs=Fals... |
filtered += wc.filter.applyfilter(wc.filter.FILTER_RESPONSE_MODIFY, "", 'finish', attrs) | filtered += wc.filter.applyfilter( wc.filter.STAGE_RESPONSE_MODIFY, "", 'finish', attrs) | def _main (): """USAGE: test/run.sh test/filterfile.py <config dir> <.html file>""" if len(sys.argv)!=3: print _main.__doc__ sys.exit(1) confdir = sys.argv[1] fname = sys.argv[2] if fname=="-": f = sys.stdin else: f = file(fname) logfile = os.path.join(confdir, "logging.conf") wc.initlog(logfile, wc.Name, filelogs=Fals... |
wc.log.debug(wc.LOG_PROXY, '%s server_response %r (%d)', | wc.log.debug(wc.LOG_PROXY, '%s server_response %r (%r)', | def server_response (self, server, response, status, headers): """read and filter server response data""" assert server.connected, "%s server was not connected" % self wc.log.debug(wc.LOG_PROXY, '%s server_response %r (%d)', self, response, status) # try google options if status in wc.google.google_try_status and \ wc.... |
f = tarfile.gzopen(source) | f = TarFile.gzopen(source) | def blacklist (file): source = "downloads/"+file # extract tar if file.endswith(".tar.gz"): print "extracting archive..." d = "extracted/"+file[:-7] f = tarfile.gzopen(source) for m in f: a, b = os.path.split(m.name) a = os.path.basename(a) if b in myfiles and a in mycats: print m.name f.extract(m, d) f.close() read_bl... |
if not os.path.exists(small_file): | if not os.path.exists("downloads/%s"%smallfile): | def dmozlists (file): print "filtering %s..." % file smallfile = "small_%s"%file if not os.path.exists(small_file): os.system(("zcat downloads/%s | config/dmozfilter.py | "+ \ "gzip --best > downloads/%s") % (file, smallfile)) file = smallfile print "dmozlist %s..." % file f = gzip.GzipFile("downloads/"+file) line = f.... |
lines.append(' bindaddress="%s"' % xmlquoteattr(self['bindaddress')) | lines.append(' bindaddress="%s"' % xmlquoteattr(self['bindaddress'])) | def write_proxyconf (self): """write proxy configuration""" lines = [] lines.append('<?xml version="1.0" encoding="%s"?>' % ConfigCharset) lines.append('<!DOCTYPE webcleaner SYSTEM "webcleaner.dtd">') lines.append('<webcleaner') lines.append(' version="%s"' % xmlquoteattr(self['version'])) lines.append(' bindaddress="%... |
out = wc.webgui.TAL.TALInterpreter.FasterStringIO() | out = wc.webgui.ZTUtils.FasterStringIO() | def render (self, context): """Render this Page Template""" out = wc.webgui.TAL.TALInterpreter.FasterStringIO() __traceback_supplement__ = \ |
"After DELAY seconds, run the CALLBACK function" | debug(PROXY, "Adding %s to %d timers", callback, len(TIMERS)) | def make_timer (delay, callback): "After DELAY seconds, run the CALLBACK function" TIMERS.append( (time.time()+delay, callback) ) TIMERS.sort() debug(PROXY, "%d timers", len(TIMERS)) |
debug(PROXY, "%d timers", len(TIMERS)) | def make_timer (delay, callback): "After DELAY seconds, run the CALLBACK function" TIMERS.append( (time.time()+delay, callback) ) TIMERS.sort() debug(PROXY, "%d timers", len(TIMERS)) | |
self.filt("""<script src=" | self.filt("""<script src="http://ivwbox.de"></script>""", "") | def testFilter (self): self.filt("""<script src="#ivwbox.de"></script>""", "") |
print "XXX read" | def rawrequest3 (url, port): """raw request with proxy CONNECT protocol""" from wc.proxy.Dispatcher import create_socket from urllib import splitnport parts = urlparse.urlsplit(url) host, sslport = splitnport(parts[1], 443) path = urlparse.urlunsplit(('', '', parts[2], parts[3], parts[4])) _sock = create_socket(socket.... | |
print "Oops" | if msg[0] != 6: print "Oops", msg | def rawrequest3 (url, port): """raw request with proxy CONNECT protocol""" from wc.proxy.Dispatcher import create_socket from urllib import splitnport parts = urlparse.urlsplit(url) host, sslport = splitnport(parts[1], 443) path = urlparse.urlunsplit(('', '', parts[2], parts[3], parts[4])) _sock = create_socket(socket.... |
ratings.clear() | def _reset_ratings (): ratings.clear() for category, catdata in service['categories'].items(): if catdata['rvalues']: ratings[category] = catdata['rvalues'][0] else: ratings[category] = "" values.clear() for category, value in ratings.items(): if category not in ["generic", "modified"]: values[category] = {value: True}... | |
values.clear() for category, value in ratings.items(): if category not in ["generic", "modified"]: values[category] = {value: True} | values[category] = {} for value in catdata['rvalues']: values[category][value] = False | def _reset_ratings (): ratings.clear() for category, catdata in service['categories'].items(): if catdata['rvalues']: ratings[category] = catdata['rvalues'][0] else: ratings[category] = "" values.clear() for category, value in ratings.items(): if category not in ["generic", "modified"]: values[category] = {value: True}... |
info = {} error = {} ratings = {} values = {} rating_modified = {} | def _calc_ratings_display (): global ratings_display urls = rating_cache.keys() urls.sort() ratings_display = urls[curindex:curindex+_entries_per_page] for _url in ratings_display: t = _strtime(float(rating_cache[_url]['modified'])) rating_modified[_url] = t.replace(u" ", u" ") | |
info.clear() error.clear() | for key in info.keys(): info[key] = False for key in error.keys(): error[key] = False | def _form_reset (): info.clear() error.clear() _reset_ratings() global url, generic, curindex url = u"" generic = False curindex = 0 |
script = escape_js(remove_html_comments(script)) if not jscomments: script = remove_js_comments(script) | script = escape_js(remove_html_comments(script, jscomments=jscomments)) | def clean (script, jscomments=True): """ Clean script from comments and HTML. """ script = escape_js(remove_html_comments(script)) if not jscomments: script = remove_js_comments(script) return u"\n<!--\n%s\n//-->\n" % script |
def remove_whitespace (script): lines = [] for line in script.splitlines(): line = line.rstrip() if line: lines.append(line) return "\n".join(lines) | def clean (script, jscomments=True): """ Clean script from comments and HTML. """ script = escape_js(remove_html_comments(script)) if not jscomments: script = remove_js_comments(script) return u"\n<!--\n%s\n//-->\n" % script | |
if script[i:i+9].lower() == '</script>' and quote: script = script[:i]+"</scr"+quote+"+"+quote+"ipt>"+\ script[(i+9):] | if script[i:i+9].lower() == '</script>': if quote: script = script[:i] + "</scr" + quote + "+" + \ quote + "ipt>" + script[(i+9):] else: script = script[:i] + script[(i+9):] | def escape_js_line (script): # if we encounter "</script>" in the script, we assume that is # in a quoted string. The solution is to split it into # "</scr"+"ipt>" (with the proper quotes of course) quote = False escape = False i = 0 while i < len(script): c = script[i] if c == '"' or c == "'": if not escape: if quote ... |
def remove_html_comments (script): | def remove_html_comments (script, jscomments=True): | def remove_html_comments (script): """ Remove leading and trailing HTML comments from the script text. """ script = remove_whitespace(script) mo = _start_js_comment(script) if mo: script = script[mo.end():] mo = _end_js_comment(script) if mo: if mo.group("comment") is not None: i = script.rindex("//") else: i = script.... |
script = remove_whitespace(script) | lines = [] for line in script.splitlines(): line = line.rstrip() if line and (jscomments or not line.lstrip().startswith('//')): lines.append(line) script = "\n".join(lines) | def remove_html_comments (script): """ Remove leading and trailing HTML comments from the script text. """ script = remove_whitespace(script) mo = _start_js_comment(script) if mo: script = script[mo.end():] mo = _end_js_comment(script) if mo: if mo.group("comment") is not None: i = script.rindex("//") else: i = script.... |
fp = gzip.GzipFile('', 'rb', 9, StringIO(content)) | fp = gzip.GzipFile('', 'rb', 9, StringIO.StringIO(content)) | def decode (page): "gunzip or deflate a compressed page" encoding = page.info().get("Content-Encoding") if encoding in ('gzip', 'x-gzip', 'deflate'): # cannot seek in socket descriptors, so must get content now content = page.read() if encoding == 'deflate': fp = StringIO.StringIO(zlib.decompress(content)) else: fp = g... |
self._debug("JS document.write %s", `data`) | def jsProcessData (self, data): """process data produced by document.write() JavaScript""" #self._debug("JS document.write %s", `data`) self.js_output += 1 # parse recursively self.js_html.feed(data) | |
self._debug("JS: popup") | def jsProcessPopup (self): """process javascript popup""" #self._debug("JS: popup") self.js_popup += 1 | |
self._debug("buf_append_data") | def buf_append_data (self, data): """we have to make sure that we have no two following DATA things in the tag buffer. Why? To be 100% sure that an ENCLOSED match really matches enclosed data. """ #self._debug("buf_append_data") if data[0]==DATA and self.buf and self.buf[-1][0]==DATA: self.buf[-1][1] += data[1] else: s... | |
self._debug("flushbuf") | def flushbuf (self): """clear and return the output buffer""" #self._debug("flushbuf") data = self.outbuf.getvalue() self.outbuf.close() self.outbuf = StringIO() return data | |
self._debug("self.outbuf %s", `self.outbuf.getvalue()`) self._debug("self.buf %s", `self.buf`) self._debug("self.waitbuf %s", `self.waitbuf`) self._debug("self.inbuf %s", `self.inbuf.getvalue()`) | def _debugbuf (self): """print debugging information about data buffer status""" #self._debug("self.outbuf %s", `self.outbuf.getvalue()`) #self._debug("self.buf %s", `self.buf`) #self._debug("self.waitbuf %s", `self.waitbuf`) #self._debug("self.inbuf %s", `self.inbuf.getvalue()`) | |
self._debug("feed %s", `data`) | def feed (self, data): """feed some data to the parser""" if self.state=='parse': # look if we must replay something if self.waited: self.waited = 0 waitbuf, self.waitbuf = self.waitbuf, [] self.replay(waitbuf) if self.state!='parse': self.inbuf.write(data) return data = self.inbuf.getvalue() + data self.inbuf.close() ... | |
self._debug("feed") | def feed (self, data): """feed some data to the parser""" if self.state=='parse': # look if we must replay something if self.waited: self.waited = 0 waitbuf, self.waitbuf = self.waitbuf, [] self.replay(waitbuf) if self.state!='parse': self.inbuf.write(data) return data = self.inbuf.getvalue() + data self.inbuf.close() ... | |
self._debug("wait") | def feed (self, data): """feed some data to the parser""" if self.state=='parse': # look if we must replay something if self.waited: self.waited = 0 waitbuf, self.waitbuf = self.waitbuf, [] self.replay(waitbuf) if self.state!='parse': self.inbuf.write(data) return data = self.inbuf.getvalue() + data self.inbuf.close() ... | |
self._debug("flush") | def flush (self): #self._debug("flush") # flushing in wait state raises a filter exception if self.state=='wait': raise FilterWait("HtmlParser[%d]: waiting for data"%self.level) self.parser.flush() | |
self._debug("replay %s", `waitbuf`) | def replay (self, waitbuf): """call the handler functions again with buffer data""" #self._debug("replay %s", `waitbuf`) for item in waitbuf: if item[0]==DATA: self._data(item[1]) elif item[0]==STARTTAG: self.startElement(item[1], item[2]) elif item[0]==ENDTAG: self.endElement(item[1]) elif item[0]==COMMENT: self.comme... | |
self._debug("cdata %s", `data`) | def cdata (self, data): """character data""" #self._debug("cdata %s", `data`) return self._data(data) | |
self._debug("characters %s", `data`) | def characters (self, data): """characters""" #self._debug("characters %s", `data`) return self._data(data) | |
self._debug("comment %s", `data`) | def comment (self, data): """a comment; accept only non-empty comments""" #self._debug("comment %s", `data`) item = [COMMENT, data] if self.state=='wait': return self.waitbuf.append(item) if self.comments and data: self.buf.append(item) | |
self._debug("doctype %s", `data`) | def doctype (self, data): #self._debug("doctype %s", `data`) return self._data("<!DOCTYPE%s>"%data) | |
self._debug("pi %s", `data`) | def pi (self, data): #self._debug("pi %s", `data`) return self._data("<?%s?>"%data) | |
self._debug("startElement %s", `tag`) | def startElement (self, tag, attrs): """We get a new start tag. New rules could be appended to the pending rules. No rules can be removed from the list.""" # default data #self._debug("startElement %s", `tag`) tag = check_spelling(tag, self.url) item = [STARTTAG, tag, attrs] if self.state=='wait': return self.waitbuf.a... | |
self._debug("matched rule %s on tag %s", `rule.title`, `tag`) | def startElement (self, tag, attrs): """We get a new start tag. New rules could be appended to the pending rules. No rules can be removed from the list.""" # default data #self._debug("startElement %s", `tag`) tag = check_spelling(tag, self.url) item = [STARTTAG, tag, attrs] if self.state=='wait': return self.waitbuf.a... | |
self._debug("put on buffer") | def startElement (self, tag, attrs): """We get a new start tag. New rules could be appended to the pending rules. No rules can be removed from the list.""" # default data #self._debug("startElement %s", `tag`) tag = check_spelling(tag, self.url) item = [STARTTAG, tag, attrs] if self.state=='wait': return self.waitbuf.a... | |
self._debug("endElement %s", `tag`) | def endElement (self, tag): """We know the following: if a rule matches, it must be the one on the top of the stack. So we look only at the top rule. | |
self._debug("JS: del %s from %s", `name`, `tag`) | def jsStartElement (self, tag, attrs): """Check popups for onmouseout and onmouseover. Inline extern javascript sources""" changed = 0 self.js_src = None self.js_output = 0 self.js_popup = 0 for name in ('onmouseover', 'onmouseout'): if attrs.has_key(name) and self.jsPopup(attrs, name): #self._debug("JS: del %s from %s... | |
self._debug("JS: jsPopup") | def jsPopup (self, attrs, name): """check if attrs[name] javascript opens a popup window""" #self._debug("JS: jsPopup") val = resolve_html_entities(attrs[name]) if not val: return self.js_env.attachListener(self) try: self.js_env.executeScriptAsFunction(val, 0.0) except jslib.error, msg: pass self.js_env.detachListener... | |
self._debug("jsForm %s action %s %s", `name`, `action`, `target`) | def jsForm (self, name, action, target): """when hitting a (named) form, notify the JS engine about that""" if not name: return #self._debug("jsForm %s action %s %s", `name`, `action`, `target`) self.js_env.addForm(name, action, target) | |
self._debug("switching back to parse with") | def jsScriptData (self, data, url, ver): """Callback for loading <script src=""> data in the background If downloading is finished, data is None""" assert self.state=='wait' if data is None: if not self.js_script: warn(PARSER, "HtmlParser[%d]: empty JS src %s", self.level, url) else: self.buf.append([STARTTAG, "script"... | |
self._debug("JS read %d <= %s", len(data), url) | def jsScriptData (self, data, url, ver): """Callback for loading <script src=""> data in the background If downloading is finished, data is None""" assert self.state=='wait' if data is None: if not self.js_script: warn(PARSER, "HtmlParser[%d]: empty JS src %s", self.level, url) else: self.buf.append([STARTTAG, "script"... | |
self._debug("JS: jsScript %s %s", ver, `script`) | def jsScript (self, script, ver, item): """execute given script with javascript version ver""" #self._debug("JS: jsScript %s %s", ver, `script`) assert self.state == 'parse' assert len(self.buf) >= 2 self.js_output = 0 self.js_env.attachListener(self) # start recursive html filter (used by jsProcessData) self.js_html =... | |
self._debug("JS: endScript") | def jsEndScript (self, item): #self._debug("JS: endScript") assert len(self.buf) >= 2 if self.js_output: try: self.js_html.feed('') self.js_html.flush() except FilterWait: self.state = 'wait' self.waited = 'True' make_timer(0.1, lambda : self.jsEndScript(item)) return self.js_html._debugbuf() assert not self.js_html.in... | |
self._debug("JS: switching back to parse with") | def jsEndScript (self, item): #self._debug("JS: endScript") assert len(self.buf) >= 2 if self.js_output: try: self.js_html.feed('') self.js_html.flush() except FilterWait: self.state = 'wait' self.waited = 'True' make_timer(0.1, lambda : self.jsEndScript(item)) return self.js_html._debugbuf() assert not self.js_html.in... | |
if data and self.statuscode != 407 and | if data and self.statuscode != 407 and \ | def flush (self): """ Flush data of decoders (if any) and filters and write it to the client. return True if flush was successful. """ assert None == wc.log.debug(wc.LOG_PROXY, "%s HttpServer.flush", self) if not self.statuscode and self.method != 'CONNECT': wc.log.warn(wc.LOG_PROXY, "%s flush without status", self) re... |
def visit_image(self, node): | class FixedHTMLTranslator (html4css1.HTMLTranslator): def visit_image (self, node): | def visit_image(self, node): """ Like html4css1.visit_image(), but with align="middle" enforcement. """ atts = node.non_default_attributes() # The XHTML standard only allows align="middle" if atts.get('align') == u"center": atts['align'] = u"middle" if atts.has_key('classes'): del atts['classes'] # prevent dupl... |
Like html4css1.visit_image(), but with align="middle" enforcement. | Like super.visit_image(), but with align="middle" enforcement. | def visit_image(self, node): """ Like html4css1.visit_image(), but with align="middle" enforcement. """ atts = node.non_default_attributes() # The XHTML standard only allows align="middle" if atts.get('align') == u"center": atts['align'] = u"middle" if atts.has_key('classes'): del atts['classes'] # prevent dupl... |
atts = node.non_default_attributes() if atts.get('align') == u"center": atts['align'] = u"middle" if atts.has_key('classes'): del atts['classes'] atts['src'] = atts['uri'] del atts['uri'] if atts.has_key('scale'): if html4css1.Image and not (atts.has_key('width') and atts.has_key('height')): | atts = {} atts['src'] = node['uri'] if node.has_key('width'): atts['width'] = node['width'] if node.has_key('height'): atts['height'] = node['height'] if node.has_key('scale'): if Image and not (node.has_key('width') and node.has_key('height')): | def visit_image(self, node): """ Like html4css1.visit_image(), but with align="middle" enforcement. """ atts = node.non_default_attributes() # The XHTML standard only allows align="middle" if atts.get('align') == u"center": atts['align'] = u"middle" if atts.has_key('classes'): del atts['classes'] # prevent dupl... |
im = html4css1.Image.open(str(atts['src'])) | im = Image.open(str(atts['src'])) | def visit_image(self, node): """ Like html4css1.visit_image(), but with align="middle" enforcement. """ atts = node.non_default_attributes() # The XHTML standard only allows align="middle" if atts.get('align') == u"center": atts['align'] = u"middle" if atts.has_key('classes'): del atts['classes'] # prevent dupl... |
atts['width'] = im.size[0] | atts['width'] = str(im.size[0]) | def visit_image(self, node): """ Like html4css1.visit_image(), but with align="middle" enforcement. """ atts = node.non_default_attributes() # The XHTML standard only allows align="middle" if atts.get('align') == u"center": atts['align'] = u"middle" if atts.has_key('classes'): del atts['classes'] # prevent dupl... |
atts['height'] = im.size[1] | atts['height'] = str(im.size[1]) | def visit_image(self, node): """ Like html4css1.visit_image(), but with align="middle" enforcement. """ atts = node.non_default_attributes() # The XHTML standard only allows align="middle" if atts.get('align') == u"center": atts['align'] = u"middle" if atts.has_key('classes'): del atts['classes'] # prevent dupl... |
if atts.has_key('width'): atts['width'] = int(round(atts['width'] * (float(atts['scale']) / 100))) if atts.has_key('height'): atts['height'] = int(round(atts['height'] * (float(atts['scale']) / 100))) del atts['scale'] if not atts.has_key('alt'): atts['alt'] = atts['src'] if isinstance(node.parent, nodes.TextElement): | for att_name in 'width', 'height': if atts.has_key(att_name): match = re.match(r'([0-9.]+)(\S*)$', atts[att_name]) assert match atts[att_name] = '%s%s' % ( float(match.group(1)) * (float(node['scale']) / 100), match.group(2)) style = [] for att_name in 'width', 'height': if atts.has_key(att_name): if re.match(r'^[0-9.]... | def visit_image(self, node): """ Like html4css1.visit_image(), but with align="middle" enforcement. """ atts = node.non_default_attributes() # The XHTML standard only allows align="middle" if atts.get('align') == u"center": atts['align'] = u"middle" if atts.has_key('classes'): del atts['classes'] # prevent dupl... |
else: div_atts = self.image_div_atts(node) self.body.append(self.starttag({}, 'div', '', **div_atts)) self.context.append('</div>\n') self.body.append(self.emptytag(node, 'img', '', **atts)) class HTMLNavTranslator (html4css1.HTMLTranslator): | self.body.append(self.emptytag(node, 'img', suffix, **atts)) class HTMLNavTranslator (FixedHTMLTranslator): | def visit_image(self, node): """ Like html4css1.visit_image(), but with align="middle" enforcement. """ atts = node.non_default_attributes() # The XHTML standard only allows align="middle" if atts.get('align') == u"center": atts['align'] = u"middle" if atts.has_key('classes'): del atts['classes'] # prevent dupl... |
<![CDATA[ | <!-- | def get_topframe_bashing (self): return """<script type="text/javascript"> |
]]> | // --> | def get_topframe_bashing (self): return """<script type="text/javascript"> |
p.feed("<hTml>") | def _test(): p = HtmlPrinter() p.feed("<hTml>") p.feed("<a href>") p.feed("<a href=''>") p.feed('<a href="">') p.feed("<a href='a'>") p.feed('<a href="a">') p.feed("<a href=a>") p.feed("<a href='\"'>") p.feed("<a href=\"'\">") p.feed("<a href=' '>") p.feed("<a href=a href=b>") p.feed("<a/>") p.feed("<a href/>") p.feed(... | |
p.feed("<a href=''>") p.feed('<a href="">') p.feed("<a href='a'>") p.feed('<a href="a">') | def _test(): p = HtmlPrinter() p.feed("<hTml>") p.feed("<a href>") p.feed("<a href=''>") p.feed('<a href="">') p.feed("<a href='a'>") p.feed('<a href="a">') p.feed("<a href=a>") p.feed("<a href='\"'>") p.feed("<a href=\"'\">") p.feed("<a href=' '>") p.feed("<a href=a href=b>") p.feed("<a/>") p.feed("<a href/>") p.feed(... | |
p.feed("<a href='\"'>") p.feed("<a href=\"'\">") p.feed("<a href=' '>") p.feed("<a href=a href=b>") p.feed("<a/>") p.feed("<a href/>") p.feed("<a href=a />") p.feed("</a>") p.feed("<?bla foo?>") p.feed("<?bla?>") p.feed("<!-- - comment -->") p.feed("<!---->") p.feed("<!DOCTYPE \"vla foo>") | def _test(): p = HtmlPrinter() p.feed("<hTml>") p.feed("<a href>") p.feed("<a href=''>") p.feed('<a href="">') p.feed("<a href='a'>") p.feed('<a href="a">') p.feed("<a href=a>") p.feed("<a href='\"'>") p.feed("<a href=\"'\">") p.feed("<a href=' '>") p.feed("<a href=a href=b>") p.feed("<a/>") p.feed("<a href/>") p.feed(... | |
p.feed(""" """) | p.feed("") | def _broken (): p = HtmlPrinter() p.feed(""" """) p.flush() |
_broken() | _test() | def _broken (): p = HtmlPrinter() p.feed(""" """) p.flush() |
for c in '<!-- -->': | for c in '<a/>': | def _broken (): p = HtmlPrinter() for c in '<!-- -->': p.feed(c) p.flush() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.