rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
self.doDTPCommand('sendFile', sioObj) | self._doDTPCommand('RETR', sioObj) | def ftp_LIST(self, params=''): """ This command causes a list to be sent from the server to the passive DTP. If the pathname specifies a directory or other group of files, the server should transfer a list of files in the specified directory. If the pathname specifies a file then the server should send current inform... |
if self.debug: log.msg('ftp_PASV') if not self.shell: if self.debug: log.msg('ftp_PASV returning, user not logged in') self.reply(NOT_LOGGED_IN) return | log.debug('ftp_PASV') | def ftp_PASV(self, *_): """Request for a passive connection |
self._createDTP() if not self.TESTING: sockname = self.transport.getHost() localip = string.replace(sockname[1], '.', ',') lport = self.dtpFactory.dtpPort.socket.getsockname()[1] lp1 = lport / 256 lp2, lp1 = str(lport - lp1*256), str(lp1) if self.HUMAN_READABLE_PASV_PORT: self.reply(ENTERING_PASV_MODE, "%s,%s" % (loc... | if not self.dtpFactory: try: self._createDTP() except OSError, e: log.msg("CRITICAL BUG!! THIS SHOULD NOT HAVE HAPPENED!!! %s" % e) sockname = self.transport.getHost() localip = string.replace(sockname[1], '.', ',') lport = self.dtpPort.socket.getsockname()[1] lp1 = lport / 256 lp2, lp1 = str(lport - lp1*256), str(lp1) | def ftp_PASV(self, *_): """Request for a passive connection |
self.doDTPCommand('sendFile', fp) | self._doDTPCommand('RETR', fp) | def ftp_RETR(self, param): try: fp = self.shell.retr(cleanPath(param)) self.doDTPCommand('sendFile', fp) except FileNotFoundError, e: self.reply(FILE_NOT_FOUND, e) except PathBelowTLDError, e: self.reply(PERMISSION_DENIED, e) |
else: | def ftp_RETR(self, param): try: fp = self.shell.retr(cleanPath(param)) self.doDTPCommand('sendFile', fp) except FileNotFoundError, e: self.reply(FILE_NOT_FOUND, e) except PathBelowTLDError, e: self.reply(PERMISSION_DENIED, e) | |
data = ' '.join(data.split())+' ' | data = data.replace('\r', ' ') data = data.replace('\n', ' ') data = normalizeRE.sub(' ', data) | def gotText(self, data): if self.ignoring: return if self.normalizing: data = ' '.join(data.split())+' ' self.writer(data) |
self.writer('\\'+level*'sub'+'section{') | self.writer('\n\n\\'+level*'sub'+'section{') | def _headerStart(self, h, attributes): level = int(h[1])-2 level += self.baseLevel self.writer('\\'+level*'sub'+'section{') |
As you can see, you define optFlags as a list of paramaters that are either on or off. optStrings are paramaters with options that need to be assigned to them. If you want to handle your own options, define a method named opt_paramname that takes (self, option) as paramaters. option will be whatever immediately follows... | As you can see, you define optFlags as a list of paramaters (with both long and short names) that are either on or off. optStrings are paramaters with string values, with their default value as the third parameter in the list. If you want to handle your own options, define a method named opt_paramname that takes (sel... | def opt_debug(self, opt): if opt == "yes" or opt == "y" or opt == "1": self.debug = 1 elif opt == "no" or opt == "n" or opt == "0": self.debug = 0 else: print "Unkown value for debug, setting to 0" self.debug = 0 |
self.deferred.armAndErrback(error.ConnectionError(string="Connection failed")) | self.deferred.armAndErrback(error.ConnectError(string="Connection failed")) | def connectionFailed(self): if not self.term: self.term = 1 del self.broker self.deferred.armAndErrback(error.ConnectionError(string="Connection failed")) |
app.reportProfile(config['report-profile'], application.processName) | app.reportProfile(config['report-profile'], service.IProcess(application).processName) | def runApp(config): passphrase = app.getPassphrase(config['encrypted']) app.installReactor(config['reactor']) application = app.getApplication(config, passphrase) oldstdout = sys.stdout oldstderr = sys.stderr startLogging(config['logfile']) app.initialLog() os.chdir(config['rundir']) service.IService(application).privi... |
val = eval(code, self.namespace) | out = sys.stdout sys.stdout = StringIO.StringIO() try: val = eval(code, self.namespace) finally: rtval = sys.stdout.getvalue() sys.stdout = out | def perspective_do(self, mesg): fn = "$manhole" try: code = compile(mesg, fn, 'eval') except: try: code = compile(mesg, fn, 'exec') except: io = StringIO.StringIO() traceback.print_exc(file=io) return io.getvalue() try: val = eval(code, self.namespace) except: io = StringIO.StringIO() traceback.print_exc(file=io) retur... |
return io.getvalue() return val | return rtval + io.getvalue() if val is not None: return rtval + '\n' + val else: return rtval | def perspective_do(self, mesg): fn = "$manhole" try: code = compile(mesg, fn, 'eval') except: try: code = compile(mesg, fn, 'exec') except: io = StringIO.StringIO() traceback.print_exc(file=io) return io.getvalue() try: val = eval(code, self.namespace) except: io = StringIO.StringIO() traceback.print_exc(file=io) retur... |
self.execute() | if self.execute: self.execute() | def finish(self): self._finished.append(1) self.execute() |
self.execute() | if self.execute: self.execute() | def callback(self, value): self._results.append(value) self.execute() |
expectedHeaders = {'Request' : '/foo/bar', 'Command' : 'GET', 'Version' : 'HTTP/1.0', 'Content-Length' : '21'} | expectedHeaders = {'request' : '/foo/bar', 'command' : 'GET', 'version' : 'HTTP/1.0', 'content-length' : '21'} | def testBuffer(self): b = StringIOWithoutClosing() a = http.HTTPChannel() a.requestFactory = DummyHTTPHandler a.makeConnection(protocol.FileWrapper(b)) # one byte at a time, to stress it. for byte in self.requests: a.dataReceived(byte) a.connectionLost() value = b.getvalue() if value != self.expected_response: for i in... |
print "status" | def _handleStatus(self, version, status, message): print "status" self.gotStatus = 1 self.assertEquals(version, "HTTP/1.0") self.assertEquals(status, "200") | |
print "response" | def _handleResponse(self, data): print "response" self.gotResponse = 1 self.assertEquals(data, "'''\n10\n0123456789'''\n") | |
self.assertEquals(self.expectedHeaders[key], value) | self.assertEquals(self.expectedHeaders[string.lower(key)], value) | def _handleHeader(self, key, value): self.numHeaders = self.numHeaders + 1 self.assertEquals(self.expectedHeaders[key], value) |
print "headers" | def _handleEndHeaders(self): print "headers" self.gotEndHeaders = 1 self.assertEquals(self.numHeaders, 4) | |
self.listenerTCP.loseConnection() d = defer.maybeDeferred(self.listenerUDP.stopListening) | d1 = self.listenerTCP.loseConnection() d2 = defer.maybeDeferred(self.listenerUDP.stopListening) d = defer.gatherResults([d1, d2]) | def tearDown(self): self.listenerTCP.loseConnection() d = defer.maybeDeferred(self.listenerUDP.stopListening) def disconnectTransport(ignored): if getattr(self.resolver.protocol, 'transport', None) is not None: return self.resolver.protocol.transport.stopListening() d.addCallback(disconnectTransport) d.addCallback(lamb... |
d = clientCreator.connectTCP("127.0.0.1", portNum) | d2 = clientCreator.connectTCP("127.0.0.1", portNum) | def _rememberProtocolInstance(addr): protocol = buildProtocol(addr) self.serverProtocol = protocol.wrappedProtocol return protocol |
return d.addCallback(gotClient) | d2.addCallback(gotClient) return defer.gatherResults([d1, d2]) | def gotClient(client): self.client = client |
mapStart_q = mapEnd_q = '"' | mapStart_q = "``" mapEnd_q = "''" | def end_div(self, _): class_ = self.divs.pop() if class_: self.gotTagEnd('div_'+class_) |
raise NotImplementedError() | raise NotImplementedError("%s does not implement writeVector()" % (self.__class__.__name__,)) | def writeVector(self, data): raise NotImplementedError() |
if not self.vector: return 0 l = self.writeVector(self.vector) if l < 0 or isinstance(l, Exception): return l if l == 0 and self.vector: result = 0 else: result = None | if self.vector: l = self.writeVector(self.vector) if l < 0 or isinstance(l, Exception): return l if l == 0 and self.vector: result = 0 else: result = None | def doWrite(self): if not self.vector: return 0 l = self.writeVector(self.vector) if l < 0 or isinstance(l, Exception): return l if l == 0 and self.vector: result = 0 else: result = None if not self.vector: self.stopWriting() if self.producer is not None and ((not self.streamingProducer) or self.producerPaused): self.p... |
checker.allowedClasses['div']['latexmacros'] = 1 checker.allowedClasses['span']['latexformula'] = 1 | checker.allowedClasses['div'].__self__['latexmacros'] = 1 checker.allowedClasses['span'].__self__['latexformula'] = 1 | def generate_lint(self, d): checker = lint.getDefaultChecker() checker.allowedClasses = checker.allowedClasses.copy() checker.allowedClasses['div']['latexmacros'] = 1 checker.allowedClasses['span']['latexformula'] = 1 return lambda file, linkrel: lint.doFile(file, checker) |
"""See twisted.internet.interfaces.IReactorCore.callFromThread. | """See twisted.internet.interfaces.IReactorThreads.callFromThread. | def callFromThread(self, f, *args, **kw): """See twisted.internet.interfaces.IReactorCore.callFromThread. """ assert callable(f), "%s is not callable" % f if threadable.isInIOThread(): self.callLater(0, f, *args, **kw) else: # lists are thread-safe in CPython, but not in Jython # this is probably a bug in Jython, but u... |
self.consumer.unregisterProducer() self.finishedCallback.callback(None) | if self.consumer is not None: self.consumer.unregisterProducer() if self.finishedCallback is not None: self.finishedCallback.callback(None) | def _doWrite(self, data): if self.consumer is None: return if data is None: # The end. self.consumer.unregisterProducer() self.finishedCallback.callback(None) self.finishedCallback = self.deferred = self.consumer = self.stream = None return self.deferred = None if self.enforceStr: # XXX: sucks that we have to do this.... |
self.connector() | if self.totalConnections<self.numberRounds: self.connector() | def _connectionMade(self): self.totalConnections += 1 self.connector() |
childFDs[2] = self.factory.stderrFile | childFDs[2] = self.factory.stderrFile.fileno() | def connectionMade(self): sockFD = self.transport.fileno() childFDs = {0: sockFD, 1: sockFD} if self.factory.stderrFile: childFDs[2] = self.factory.stderrFile |
None, None, service.user, service.group, childFDs) | None, None, uid, gid, childFDs) | def connectionMade(self): sockFD = self.transport.fileno() childFDs = {0: sockFD, 1: sockFD} if self.factory.stderrFile: childFDs[2] = self.factory.stderrFile |
if href.startswith('http://') or href.startswith('https://'): | if urlparse.urlparse(href)[0] in supported_schemes: | def visitNode_a_href(self, node): self.visitNodeDefault(node) href = node.getAttribute('href') if href.startswith('http://') or href.startswith('https://'): if node.childNodes[0].data != href: self.writer('\\footnote{%s}' % latexEscape(href)) elif href.startswith('mailto:'): pass else: if href.startswith('#'): href = s... |
elif href.startswith('mailto:'): pass | def visitNode_a_href(self, node): self.visitNodeDefault(node) href = node.getAttribute('href') if href.startswith('http://') or href.startswith('https://'): if node.childNodes[0].data != href: self.writer('\\footnote{%s}' % latexEscape(href)) elif href.startswith('mailto:'): pass else: if href.startswith('#'): href = s... | |
def receiveDirectMessage(self, senderName, message): | def receiveDirectMessage(self, senderName, message, metadata=None): | def receiveDirectMessage(self, senderName, message): #>> :glyph_!glyph@adsl-64-123-27-108.dsl.austtx.swbell.net PRIVMSG glyph_ :hello #>> :glyph!glyph@adsl-64-123-27-108.dsl.austtx.swbell.net PRIVMSG glyph_ :hello |
lines = string.split(message, '\n') for line in lines: self.sendLine(":%s!%s@%s PRIVMSG %s :%s" % (senderName, senderName, self.servicename, self.nickname, line)) def receiveGroupMessage(self, sender, group, message): | if (metadata is not None) and (metadata['style'] == 'emote'): message = irc.ctcpStringify([('ACTION', message)]) self.sendLine(":%s!%s@%s PRIVMSG %s :%s" % (senderName, senderName, self.servicename, self.nickname, irc.lowQuote(message))) def receiveGroupMessage(self, sender, group, message, metadata=None): if (metad... | def receiveDirectMessage(self, senderName, message): #>> :glyph_!glyph@adsl-64-123-27-108.dsl.austtx.swbell.net PRIVMSG glyph_ :hello #>> :glyph!glyph@adsl-64-123-27-108.dsl.austtx.swbell.net PRIVMSG glyph_ :hello |
lines = string.split(message, '\n') for line in lines: self.sendLine(":%s!%s@%s PRIVMSG (sender, sender, self.servicename, group, line)) | self.sendLine(":%s!%s@%s PRIVMSG (sender, sender, self.servicename, group, irc.lowQuote(message))) | def receiveGroupMessage(self, sender, group, message): if sender is not self: lines = string.split(message, '\n') for line in lines: self.sendLine(":%s!%s@%s PRIVMSG #%s :%s" % (sender, sender, self.servicename, group, line)) |
meth = getattr(self.im_class, self.im_func) | def receiveClose(self): assert self.state == 3 meth = getattr(self.im_class, self.im_func) if self.im_self is None: return meth # TODO: late-available instances #if isinstance(self.im_self, NotKnown): # im = _InstanceMethod(self.im_name, self.im_self, self.im_class) # return im im = instancemethod(meth, self.im_s... | |
flags = tuple(parseNestedList(parts[1])) | flags = tuple(parseNestedParens(parts[1])) | def auth_APPEND(self, tag, args): parts = splitQuoted(args) if len(parts) == 2: flags = () date = rfc822.formatdate() size = parts[1] elif len(parts) == 3: if parts[1].startswith('(') and parts[1].endswith(')'): flags = tuple(parseNestedList(parts[1])) date = rfc822.formatdate() else: flags = () date = parts[1] size = ... |
c.connectionLost = self.sendEOF | c.connectionLost = lambda x=None,s=self:s.sendEOF() | def channelOpen(self, foo): #global globalSession #globalSession = self # turn off local echo if options['agent']: d = self.conn.sendRequest(self, 'auth-agent-req@openssh.com', '', wantReply=1) d.addBoth(lambda x:log.msg(x)) if options['noshell']: return if (options['command'] and options['tty']) or not options['notty'... |
supportedTerms = ['xterm', 'xterm-color', 'linux', 'screen'] if not os.environ.has_key('TERM'): | import sys if not sys.stderr.isatty(): return False try: import curses curses.setupterm() return curses.tigetnum("colors") > 2 except: | def _supportsColor(self): supportedTerms = ['xterm', 'xterm-color', 'linux', 'screen'] if not os.environ.has_key('TERM'): return False return os.environ['TERM'] in supportedTerms |
return os.environ['TERM'] in supportedTerms | def _supportsColor(self): supportedTerms = ['xterm', 'xterm-color', 'linux', 'screen'] if not os.environ.has_key('TERM'): return False return os.environ['TERM'] in supportedTerms | |
self.transport.loseConnection() | self.disconnect() | def connectionMade(self): if DENY_CONNECTION: self.transport.loseConnection() return |
self.transport.loseConnection() | self.disconnect() | def lineReceived(self, line): """Error Conditions""" uline = line.upper() find = lambda s: uline.find(s) != -1 |
self.sendLine('+OK TLS not available') | self.sendLine('-ERR TLS not available') | def startTLS(self): if self.ctx is None: self.getContext() |
('DCC', ['SEND', 'RESUME', fileName, port, resumePos])]) | ('DCC', ['RESUME', fileName, port, resumePos])]) | def dccResume(self, user, fileName, port, resumePos): """Send a DCC RESUME request to another user.""" self.ctcpMakeQuery(user, [ ('DCC', ['SEND', 'RESUME', fileName, port, resumePos])]) |
('DCC', ['SEND', 'ACCEPT', fileName, port, resumePos])]) | ('DCC', ['ACCEPT', fileName, port, resumePos])]) | def dccAcceptResume(self, user, fileName, port, resumePos): """Send a DCC ACCEPT response to clients who have requested a resume. """ self.ctcpMakeQuery(user, [ ('DCC', ['SEND', 'ACCEPT', fileName, port, resumePos])]) |
dcctype = data[0].upper() if dcctype in ('RESUME', 'ACCEPT'): handler = getattr(self, 'dcc_SEND_' + dcctype, None) data.pop() handler(user, channel, data) return | def dcc_SEND(self, user, channel, data): # Use splitQuoted for those who send files with spaces in the names. data = text.splitQuoted(data) if len(data) < 3: raise IRCBadMessage, "malformed DCC SEND request: %r" % (data,) | |
print 'called conv' | def _conv(p, items, foo): print 'called conv' try: d = conv(items) except: import traceback print 'FOOOFOFOFOSDFOSDF' traceback.print_exc() return ev = threading.Event() def cb(r): ev.r = (1, r) ev.set() def eb(e): ev.r = (0, e) ev.set() reactor.callFromThread(d.addCallbacks, cb, eb) ev.wait() print 'ASDASDASDASD' done... | |
print 'FOOOFOFOFOSDFOSDF' | def _conv(p, items, foo): print 'called conv' try: d = conv(items) except: import traceback print 'FOOOFOFOFOSDFOSDF' traceback.print_exc() return ev = threading.Event() def cb(r): ev.r = (1, r) ev.set() def eb(e): ev.r = (0, e) ev.set() reactor.callFromThread(d.addCallbacks, cb, eb) ev.wait() print 'ASDASDASDASD' done... | |
print 'ASDASDASDASD' | def eb(e): ev.r = (0, e) ev.set() | |
n.setAttribute("parent:connect", "%s:%d" % (connector.host, str(connector.portno))) | n.setAttribute("parent:connect", "%s:%d" % (connector.host, connector.portno)) | def jellyToDOM_1(self, jellier, node): if hasattr(self, 'uid'): node.setAttribute("uid", str(self.uid)) node.setAttribute("gid", str(self.gid)) node.setAttribute("name", self.name) tcpnode = jellier.document.createElement("tcp") node.appendChild(tcpnode) svcnode = jellier.document.createElement("services") node.appendC... |
body = "<HTML><BODY><br>web.Server Traceback \n\n" + html.PRE(io.getvalue()) + "\n\n</body></html>" | body = "<HTML><BODY><br>web.Server Traceback \n\n" + html.PRE(io.getvalue()) + "\n\n</body></html>\n" | def process(self): "Process a request." # Log the request to a file. print self # cache the client information, we'll need this later to be pickled and # sent with the request so CGIs will work remotely self.client = self.transport.getPeer() # set various default headers self.setHeader('server', version) self.setHead... |
self.factory.startFactory() | def startListening(self): """Create and bind my socket, and begin listening on it. | |
from twisted.web2 import stream import sys stream.readStream(response.stream, lambda x: (sys.stderr.write(x), sys.stderr.write("\n"))) | def do_test(response): response = IResponse(response) | |
class Redirect(resource.Resource): def __init__(self, url): self.url = url def render(self, request): request.setHeader("location", self.url) request.setResponseCode(http.TEMPORARY_REDIRECT) return """ | def addSlash(request): return "http://%s%s/" % ( request.getHeader("host"), (string.split(request.uri,'?')[0])) def redirectTo(URL, request): request.setHeader("location", URL) request.setResponseCode(http.TEMPORARY_REDIRECT) return """ | def render(self, request): request.setHeader("content-type", self.type) if request.method == "HEAD": request.setHeader("content-length", len(self.data)) return '' return self.data |
""" % {'url': self.url} | """ % {'url': URL} class Redirect(resource.Resource): def __init__(self, request): self.url = addSlash(request) def render(self, request): return redirectTo(self.url, request) | def render(self, request): request.setHeader("location", self.url) request.setResponseCode(http.TEMPORARY_REDIRECT) return """ |
return self.redirect(request) | return Redirect(request) | def getChild(self, path, request): """See twisted.web.Resource.getChild. """ if path == '..': return error.NoResource("Invalid request URL.") |
index = self.getIndex(request) if index: return index.render(request) return self.redirect(request).render(request) | if self.path[-1] == '/': index = self.getIndex(request) if index: return index.render(request) else: return self.redirect(request) | def render(self, request): "You know what you doing." mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime =\ os.stat(self.path) |
redirectURL = "http://%s%s/" % ( request.getHeader("host"), (string.split(request.uri,'?')[0])) return Redirect(redirectURL) | return redirectTo(addSlash(request), request) | def redirect(self, request): redirectURL = "http://%s%s/" % ( request.getHeader("host"), (string.split(request.uri,'?')[0])) return Redirect(redirectURL) |
I will login as soon as I receive the weclome message from the server. | I will login as soon as I receive the welcome message from the server. | def __init__(self, username='anonymous', password='twisted@twistedmatrix.com', passive=1): """Constructor. |
cmd.deferred.addErrback(portCmd.fail) | cmd.deferred.addErrback(lambda e, pc=portCmd: pc.fail(e) or e) cmd.deferred.addErrback(portCmd.realDeferred.errback) cmd.deferred.arm() | abcdef = re.sub('[^0-9, ]', '', line[4:]) |
listener = FTPDataPort(0, FTPDataPortFactory()) | factory = FTPDataPortFactory() listener = FTPDataPort(0, factory) factory.port = listener | def newCL(oldCL=oldCL, portCmd=portCmd): oldCL() portCmd.realDeferred.callback(portCmd.protocol) |
while factory.line is None: reactor.iterate(0.1) | util.spinWhile(lambda :factory.line is None) | def lineReceived(self, line): self.factory.line = line |
while not l: reactor.iterate(0.1) | util.spinWhile(lambda :not l) | def testUDP(self): if not interfaces.IReactorUDP(reactor, None): raise unittest.SkipTest, "This reactor does not support UDP sockets" p = protocol.DatagramProtocol() t = internet.TCPServer(0, p) t.startService() num = t._port.getHost().port l = [] defer.maybeDeferred(t.stopService).addCallback(l.append) while not l: re... |
while not l: reactor.iterate(0.1) | util.spinWhile(lambda :not l) | def testConnectionGettingRefused(self): factory = protocol.ServerFactory() factory.protocol = wire.Echo t = internet.TCPServer(0, factory) t.startService() num = t._port.getHost().port t.stopService() l = [] factory = protocol.ClientFactory() factory.clientConnectionFailed = lambda *args: l.append(None) c = internet.TC... |
while not l: reactor.iterate(0.1) | util.spinWhile(lambda :not l) | def lineReceived(self, line): self.factory.line = line |
while not l: reactor.iterate(0.1) | util.spinWhile(lambda :not l) | def testStoppingServer(self): if not interfaces.IReactorUNIX(reactor, None): raise unittest.SkipTest, "This reactor does not support UNIX domain sockets" factory = protocol.ServerFactory() factory.protocol = wire.Echo t = internet.UNIXServer('echo.skt', factory) t.startService() t.stopService() self.failIf(t.running) f... |
timeout = 30 | def testTimer(self): timeout = 30 l = [] t = internet.TimerService(1, l.append, "hello") t.startService() while not l: reactor.iterate(0.1) timeout -= 1 self.failIf(timeout == 0) t.stopService() self.failIf(t.running) self.assertEqual(l, ["hello"]) l.pop() | |
while not l: reactor.iterate(0.1) timeout -= 1 self.failIf(timeout == 0) | util.spinWhile(lambda :not l, timeout=30) | def testTimer(self): timeout = 30 l = [] t = internet.TimerService(1, l.append, "hello") t.startService() while not l: reactor.iterate(0.1) timeout -= 1 self.failIf(timeout == 0) t.stopService() self.failIf(t.running) self.assertEqual(l, ["hello"]) l.pop() |
timeout = 30 t.startService() while not l: reactor.iterate(0.1) timeout -= 1 self.failIf(timeout == 0) | t.startService() util.spinWhile(lambda :not l, timeout=30) | def testTimer(self): timeout = 30 l = [] t = internet.TimerService(1, l.append, "hello") t.startService() while not l: reactor.iterate(0.1) timeout -= 1 self.failIf(timeout == 0) t.stopService() self.failIf(t.running) self.assertEqual(l, ["hello"]) l.pop() |
while len(l)<10: reactor.iterate(0.1) timeout -= 1 self.failIf(timeout == 0) | util.spinWhile(lambda :len(l) < 10, timeout=30) | def testTimer(self): timeout = 30 l = [] t = internet.TimerService(1, l.append, "hello") t.startService() while not l: reactor.iterate(0.1) timeout -= 1 self.failIf(timeout == 0) t.stopService() self.failIf(t.running) self.assertEqual(l, ["hello"]) l.pop() |
timeout = 30 t.startService() while t._loop.running: reactor.iterate(0.1) timeout -= 1 self.failIf(timeout == 0) | t.startService() util.spinWhile(lambda :t._loop.running, timeout=30) | def testBrokenTimer(self): t = internet.TimerService(1, lambda: 1 / 0) timeout = 30 t.startService() while t._loop.running: reactor.iterate(0.1) timeout -= 1 self.failIf(timeout == 0) t.stopService() self.assertEquals([ZeroDivisionError], [o.value.__class__ for o in log.flushErrors(ZeroDivisionError)]) |
if not request.prepath[-1] == '' and self.addSlash: | if self.addSlash and request.prepath[-1] != '' and request.prepath[-1] != 'index.rpy': | def render(self, request): """ Trigger any inputhandlers that were passed in to this Page, then delegate to the View for traversing the DOM. Finally, call gatheredControllers to deal with any InputHandlers that were constructed from any controller= tags in the DOM. gatheredControllers will render the page to the browse... |
from twisted.internet import defer from twisted.python import failure defer.Deferred.debug = True failure.startDebugMode() | def seeWarnings(x): if x.has_key('warning'): print print x['format'] % x | |
print "error parsing remote-interface attributes in %s" % iname | def __init__(self, iname, bases=(), attrs=None, __module__=None): if attrs is None: interface.InterfaceClass.__init__(self, iname, bases, attrs, __module__) return | |
print "error registering RemoteInterface '%s'" % rname | def __init__(self, iname, bases=(), attrs=None, __module__=None): if attrs is None: interface.InterfaceClass.__init__(self, iname, bases, attrs, __module__) return | |
def __init__(self): pass | def __init__(self): pass | |
responses = PropStatResponseQueue("PROPPATCH", request.uri, responsecode.NO_CONTENT) | responses = ResponseQueue(self.fp.path, "PROPPATCH", responsecode.NO_CONTENT) | def gotXML(doc): if doc is None: error = "Request XML body is required." log.err(error) return StatusResponse(responsecode.BAD_REQUEST, error) |
got_an_error = [False] | def gotXML(doc): if doc is None: error = "Request XML body is required." log.err(error) return StatusResponse(responsecode.BAD_REQUEST, error) | |
def do(action, property): | def do(action, property, request): | def do(action, property): # # Perform action(property, request) while maintaining an # undo queue. # if self.hasProperty(property, request): old_property = self.readProperty(property, request) def undo(): self.writeProperty(old_property, request) else: def undo(): self.removeProperty(property, request) |
propitem = davxml.lookupElement(property.qname())() except KeyError: class UnknownElement (davxml.WebDAVUnknownElement): namespace = property.qname()[0] name = property.qname()[1] propitem = UnknownElement() | action(property, request) except: responses.add(self.fp.path, Failure()) else: responses.add(self.fp.path, responsecode.OK) | def undo(): self.removeProperty(property, request) |
try: action(property, request) except ValueError, e: responses.add(Failure(exc_value=HTTPError(StatusResponse(responsecode.FORBIDDEN, str(e)))), davxml.PropertyContainer(propitem)) got_an_error[0] = True except: responses.add(Failure(), davxml.PropertyContainer(propitem)) got_an_error[0] = True else: responses.add(res... | undo_actions.append(undo) | def undo(): self.removeProperty(property, request) |
do(self.writeProperty, property) | do(self.writeProperty, property, request) | def undo(): self.removeProperty(property, request) |
do(self.removeProperty, property) | do(self.removeProperty, property, request) | def undo(): self.removeProperty(property, request) |
if got_an_error[0]: for action in undo_actions: action() responses.error() | def undo(): self.removeProperty(property, request) | |
return MultiStatusResponse([responses.response()]) | return responses.response() | def undo(): self.removeProperty(property, request) |
log.msg("Error, gtk doIteration() only supports delay of 0") gtk.mainiteration() | time.sleep(delay) gtk.mainiteration(0) | def doIteration(self, delay=0.0): if delay != 0: log.msg("Error, gtk doIteration() only supports delay of 0") gtk.mainiteration() |
methods = [] cbNames = [] if condition & gtk.GDK.INPUT_READ: methods.append(getattr(source, 'doRead')) cbNames.append('doRead') if (condition & gtk.GDK.INPUT_WRITE): method = getattr(source, 'doWrite') if not (method in methods): methods.append(method) cbNames.append('doWrite') for method, cbName in zip(methods, cb... | log.logOwner.own(source) why = None if 0: pass else: | def callback(self, source, condition): methods = [] cbNames = [] |
why = method() | didRead = None if condition & gtk.GDK.INPUT_READ: why = source.doRead() didRead = source.doRead if not why and condition & gtk.GDK.INPUT_WRITE: if not source.disconnected and source.doWrite != didRead: why = source.doWrite() | def callback(self, source, condition): methods = [] cbNames = [] |
log.msg('Error In %s.%s' %(source,cbName)) | log.msg('Error In %s' % source) | def callback(self, source, condition): methods = [] cbNames = [] |
if why: try: source.connectionLost(failure.Failure(why)) except: log.deferr() self.removeReader(source) self.removeWriter(source) break elif source.disconnected: break self.simulate() | if why: self.removeReader(source) self.removeWriter(source) try: source.connectionLost(failure.Failure(why)) except: log.deferr() log.logOwner.disown(source) self.simulate() return 1 | def callback(self, source, condition): methods = [] cbNames = [] |
def _delayDeferred(self, time, arg=None): from twisted.internet import reactor d = defer.Deferred() reactor.callLater(time, d.callback, arg) return d | def _delayDeferred(self, time, arg=None): from twisted.internet import reactor d = defer.Deferred() reactor.callLater(time, d.callback, arg) return d | |
client = self.client f = self.f client.transport.write("hello") w = client.transport.write client.transport.loseWriteConnection() d = self._delayDeferred(0.2, f.protocol) d.addCallback(lambda x : self.assertEqual(f.protocol.data, 'hello')) d.addCallback(lambda x : self.assertEqual(f.protocol.closed, True)) return d | self.client.transport.write("hello") self.client.transport.loseWriteConnection() self.f.protocol.closedDeferred = d = defer.Deferred() self.client.closedDeferred = d2 = defer.Deferred() d.addCallback(lambda x: self.assertEqual(self.f.protocol.data, 'hello')) d.addCallback(lambda x: self.assertEqual(self.f.protocol.clos... | def testNoNotification(self): client = self.client f = self.f client.transport.write("hello") w = client.transport.write client.transport.loseWriteConnection() d = self._delayDeferred(0.2, f.protocol) d.addCallback(lambda x : self.assertEqual(f.protocol.data, 'hello')) d.addCallback(lambda x : self.assertEqual(f.protoc... |
client = self.client f = self.f f.protocol.transport.loseConnection() client.transport.write("X") client.transport.loseWriteConnection() d = self._delayDeferred(0.2, f.protocol) d.addCallback(lambda x : self.failUnlessEqual(x.closed, True)) return d | self.f.protocol.transport.loseConnection() self.client.transport.write("X") self.client.transport.loseWriteConnection() self.f.protocol.closedDeferred = d = defer.Deferred() self.client.closedDeferred = d2 = defer.Deferred() d.addCallback(lambda x: self.failUnlessEqual(self.f.protocol.closed, True)) return defer.gather... | def testShutdownException(self): client = self.client f = self.f f.protocol.transport.loseConnection() client.transport.write("X") client.transport.loseWriteConnection() d = self._delayDeferred(0.2, f.protocol) d.addCallback(lambda x : self.failUnlessEqual(x.closed, True)) return d |
in_ = 'foo\nhey hey $VER\nbar' | in_ = 'foo\nhey hey $VER\nbar\n' | def testReplaceInFile(self): in_ = 'foo\nhey hey $VER\nbar' outf = open('release.replace', 'w') outf.write(in_) outf.close() |
request.setResponseCode(http.MOVED_PERMANENTLY) | request.setResponseCode(http.TEMPORARY_REDIRECT) | def configWidget(self, request): # displaying the widget path = request.postpath if path: obj = self.app for elem in path: if elem: # '' doesn't count obj = obj.getStaticEntity(elem) if obj is None: request.setResponseCode(http.MOVED_PERMANENTLY) request.setHeader('location', request.prePathURL()) return... |
address = ("127.0.0.1", 19939) | def __init__(self): """Initialize. """ log.msg("starting waker") # Following select_trigger (from asyncore)'s example; address = ("127.0.0.1", 19939) server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.setsockopt(socket.IPPROTO_TCP, 1, 1) server.b... | |
server.bind(address) | server.bind(('127.0.0.1', 0)) | def __init__(self): """Initialize. """ log.msg("starting waker") # Following select_trigger (from asyncore)'s example; address = ("127.0.0.1", 19939) server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.setsockopt(socket.IPPROTO_TCP, 1, 1) server.b... |
client.connect(address) | client.connect(server.getsockname()) | def __init__(self): """Initialize. """ log.msg("starting waker") # Following select_trigger (from asyncore)'s example; address = ("127.0.0.1", 19939) server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.setsockopt(socket.IPPROTO_TCP, 1, 1) server.b... |
self.isFinished = 0 | self.stop = 0 | def __init__(self, source, extend ): """ This is the setup, the source argument is the iterator being wrapped, which exists in another thread. """ self.source = source self.isFinished = 0 self.failure = None self.buff = [] self.extend = extend |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.