rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
log.msg("Error, gtk doIteration() only supports delay of 0") gtk.main_iteration() | time.sleep(delay) gtk.main_iteration(0) | def doIteration(self, delay=0.0): if delay != 0: log.msg("Error, gtk doIteration() only supports delay of 0") gtk.main_iteration() |
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 condition & POLL_DISCONNECTED and \ not (condition & gtk._gobject.IO_IN): why = main.CONNECTION_LOST else: | def callback(self, source, condition): methods = [] cbNames = [] |
why = method() | didRead = None if condition & gtk._gobject.IO_IN: why = source.doRead() didRead = source.doRead if not why and condition & gtk._gobject.IO_OUT: if not source.disconnected and source.doWrite != didRead: why = source.doWrite() | 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() return 1 | 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 = [] |
if attr == "_v_repr": | if attr.startswith("_v_"): | def __getattr__(self, attr): if attr == "_v_repr": raise AttributeError # z.i internal thing, if attr != "__instadapt__": # __instadapt__ is part of our own backwards compat layer warnings.warn("Don't get attributes (in this case, %r) off Interface, use " ".queryDescriptionFor() etc. instead" % (attr,), ComponentsDepre... |
class Shell(Ftp): | class ShellFactory(Ftp): | def ftp_Abor(self, params): if self.checkauth(): return if self.dtp.transport.connected: self.dtp.loseConnection() self.reply('abort') |
p = sob.IPersistable(app) | p = sob.IPersistable(application) | def startApplication(application, save): from twisted.internet import reactor service.IService(application).startService() if save: p = sob.IPersistable(app) reactor.addSystemEventTrigger('after', 'shutdown', p.save, 'shutdown') reactor.addSystemEventTrigger('before', 'shutdown', service.IService(application).stopServi... |
if not bytesToRead: return | def doReadOut(self): """Runs in thread.""" try: buffer, bytesToRead, ignore = win32pipe.PeekNamedPipe(self.hStdoutR, 0) if not bytesToRead: return hr, data = win32file.ReadFile(self.hStdoutR, bytesToRead, None) except win32api.error: self.stdoutClosed = 1 if self.stderrClosed: return main.CONNECTION_LOST else: return s... | |
if not bytesToRead: return | def doReadErr(self): """Runs in thread.""" try: buffer, bytesToRead, ignore = win32pipe.PeekNamedPipe(self.hStderrR, 0) if not bytesToRead: return hr, data = win32file.ReadFile(self.hStderrR, bytesToRead, None) except win32api.error: self.stderrClosed = 1 if self.stdoutClosed: return main.CONNECTION_LOST else: return s... | |
s = internet.GenericClient(connectorType, *args, **kw) | s = internet.UDPClient(remotehost, remoteport, protocol, localport, interface, maxPacketSize) | def connectUDP(self, remotehost, remoteport, protocol, localport=0, interface='', maxPacketSize=8192): s = internet.GenericClient(connectorType, *args, **kw) s.setServiceParent(self.app) |
request = self.requestFactory(self, len(self.requests)) self.requests.append(request) | def lineReceived(self, line): self.resetTimeout() | |
if node.tagName == "None": | if node.tagName.lower() == "none": | def unjellyNode(self, node): if node.tagName == "None": retval = None elif node.tagName == "string": retval = str(eval('"%s"' % node.getAttribute("value"))) elif node.tagName == "int": retval = int(node.getAttribute("value")) elif node.tagName == "float": retval = float(node.getAttribute("value")) elif node.tagName == ... |
if metadata is not None: | if metadata is not None and metadata.has_key('style'): | def receiveDirectMessage(self, senderName, message, metadata=None): #>> :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 |
if metadata is not None: | if metadata is not None and metadata.has_key('style'): | def receiveGroupMessage(self, sender, group, message, metadata=None): if metadata is not None: message = irc.ctcpStringify([(wordsToCtcp(metadata['style']), message)]) |
self['debugflags'] = [] self['cleanup'] = [] | def __init__(self): usage.Options.__init__(self) self['tests'] = [] self['reporter'] = None self['debugflags'] = [] self['cleanup'] = [] | |
NO_BODY_CODES = (204, 304) | NO_BODY_CODES = (204, 304, 302, 303) | def rawDataReceived(self, data): if self.length is not None: data, rest = data[:self.length], data[self.length:] self.length -= len(data) else: rest = '' self.handleResponsePart(data) if self.length == 0: self.handleResponseEnd() self.setLineMode(rest) |
def _test(self, s, lines): self._testwrite(s) def asserts(ignored): self._assertBuffer(lines) return defer.maybeDeferred(self._emptyBuffers).addCallback(asserts) | def _test(self, s, lines): self._testwrite(s) def asserts(ignored): self._assertBuffer(lines) return defer.maybeDeferred(self._emptyBuffers).addCallback(asserts) | |
def _emptyBuffers(self): pass | def _emptyBuffers(self): pass | |
def _emptyBuffers(self): self.clientTransport.clearBuffer() self.serverTransport.clearBuffer() | def _testwrite(self, bytes): self.telnetClient.write(bytes) | |
def _emptyBuffers(self): from twisted.internet import reactor for i in range(100): reactor.iterate(0.01) | def _emptyBuffers(self): from twisted.internet import reactor for i in range(100): reactor.iterate(0.01) | |
return done.addCallback(finished) | def testHome(self): return self._trivialTest( insert + "blah line" + home + "home\ndone", [">>> home line", "home line", ">>> done"]) | |
def addSystemEventTrigger(self, phase, eventType, f, *args, **kw): | def addSystemEventTrigger(self, _phase, _eventType, _f, *args, **kw): | def addSystemEventTrigger(self, phase, eventType, f, *args, **kw): """See twisted.internet.interfaces.IReactorCore.addSystemEventTrigger. """ assert callable(f), "%s is not callable" % f if self._eventTriggers.has_key(eventType): triglist = self._eventTriggers[eventType] else: triglist = [[], [], []] self._eventTrigger... |
assert callable(f), "%s is not callable" % f if self._eventTriggers.has_key(eventType): triglist = self._eventTriggers[eventType] | assert callable(_f), "%s is not callable" % _f if self._eventTriggers.has_key(_eventType): triglist = self._eventTriggers[_eventType] | def addSystemEventTrigger(self, phase, eventType, f, *args, **kw): """See twisted.internet.interfaces.IReactorCore.addSystemEventTrigger. """ assert callable(f), "%s is not callable" % f if self._eventTriggers.has_key(eventType): triglist = self._eventTriggers[eventType] else: triglist = [[], [], []] self._eventTrigger... |
self._eventTriggers[eventType] = triglist evtList = triglist[{"before": 0, "during": 1, "after": 2}[phase]] evtList.append((f, args, kw)) return (phase, eventType, (f, args, kw)) | self._eventTriggers[_eventType] = triglist evtList = triglist[{"before": 0, "during": 1, "after": 2}[_phase]] evtList.append((_f, args, kw)) return (_phase, _eventType, (_f, args, kw)) | def addSystemEventTrigger(self, phase, eventType, f, *args, **kw): """See twisted.internet.interfaces.IReactorCore.addSystemEventTrigger. """ assert callable(f), "%s is not callable" % f if self._eventTriggers.has_key(eventType): triglist = self._eventTriggers[eventType] else: triglist = [[], [], []] self._eventTrigger... |
def callWhenRunning(self, callable, *args, **kw): | def callWhenRunning(self, _callable, *args, **kw): | def callWhenRunning(self, callable, *args, **kw): """See twisted.internet.interfaces.IReactorCore.callWhenRunning. """ if self.running: callable(*args, **kw) else: return self.addSystemEventTrigger('after', 'startup', callable, *args, **kw) |
callable(*args, **kw) | _callable(*args, **kw) | def callWhenRunning(self, callable, *args, **kw): """See twisted.internet.interfaces.IReactorCore.callWhenRunning. """ if self.running: callable(*args, **kw) else: return self.addSystemEventTrigger('after', 'startup', callable, *args, **kw) |
callable, *args, **kw) | _callable, *args, **kw) | def callWhenRunning(self, callable, *args, **kw): """See twisted.internet.interfaces.IReactorCore.callWhenRunning. """ if self.running: callable(*args, **kw) else: return self.addSystemEventTrigger('after', 'startup', callable, *args, **kw) |
def callLater(self, seconds, f, *args, **kw): | def callLater(self, _seconds, _f, *args, **kw): | def callLater(self, seconds, f, *args, **kw): """See twisted.internet.interfaces.IReactorTime.callLater. """ assert callable(f), "%s is not callable" % f assert sys.maxint >= seconds >= 0, "%s is not greater than or equal to 0 seconds" % (seconds,) tple = DelayedCall(time() + seconds, f, args, kw, self._pendingTimedCal... |
assert callable(f), "%s is not callable" % f assert sys.maxint >= seconds >= 0, "%s is not greater than or equal to 0 seconds" % (seconds,) tple = DelayedCall(time() + seconds, f, args, kw, self._pendingTimedCalls.remove, self._resetCallLater) | assert callable(_f), "%s is not callable" % _f assert sys.maxint >= _seconds >= 0, \ "%s is not greater than or equal to 0 seconds" % (_seconds,) tple = DelayedCall(time() + _seconds, _f, args, kw, self._pendingTimedCalls.remove, self._resetCallLater) | def callLater(self, seconds, f, *args, **kw): """See twisted.internet.interfaces.IReactorTime.callLater. """ assert callable(f), "%s is not callable" % f assert sys.maxint >= seconds >= 0, "%s is not greater than or equal to 0 seconds" % (seconds,) tple = DelayedCall(time() + seconds, f, args, kw, self._pendingTimedCal... |
def callInThread(self, callable, *args, **kwargs): | def callInThread(self, _callable, *args, **kwargs): | def callInThread(self, callable, *args, **kwargs): """See twisted.internet.interfaces.IReactorThreads.callInThread. """ if not self.threadpool: self._initThreadPool() self.threadpool.callInThread(callable, *args, **kwargs) |
self.threadpool.callInThread(callable, *args, **kwargs) | self.threadpool.callInThread(_callable, *args, **kwargs) | def callInThread(self, callable, *args, **kwargs): """See twisted.internet.interfaces.IReactorThreads.callInThread. """ if not self.threadpool: self._initThreadPool() self.threadpool.callInThread(callable, *args, **kwargs) |
name, None, lambda m=module: m.options, module.description)) | name, None, lambda m=module: m.options(), module.description)) | def init(self, tapLookup): sc = [] for (name, module) in tapLookup.iteritems(): if IServiceMaker.providedBy(module): sc.append(( name, None, lambda m=module: m.options, module.description)) else: sc.append(( name, None, lambda obj=module: obj.load().Options(), getattr(module, 'description', ''))) |
pass else: raise AssertionError, exception.__name__ | return except: raise AssertionError, '%s raised instead of %s' % (sys.exc_info()[0], exception.__name__) else: raise AssertionError, '%s not raised' % exception.__name__ | def failUnlessRaises(self, exception, f, *args, **kwargs): try: f(*args, **kwargs) except exception: pass else: raise AssertionError, exception.__name__ |
raise AssertionError, (msg or '%s != %s' (first, second)) | raise AssertionError, (msg or '%s != %s' % (first, second)) | def failUnlessEqual(self, first, second, msg=None): if not first == second: raise AssertionError, (msg or '%s != %s' (first, second)) |
if first == second: raise AssertionError, (msg or '%s == %s' (first, second)) | if not first != second: raise AssertionError, (msg or '%s == %s' % (first, second)) | def failIfEqual(self, first, second, msg=None): if first == second: raise AssertionError, (msg or '%s == %s' (first, second)) |
self.testCases = [] def addTestCase(self, testCase): methodDict = {} reflect.accumulateMethods(testCase, methodDict, self.methodPrefix) methods = methodDict.items() methods.sort() testCases = [ (testCase, method[1]) for method in methods ] self.testCases.extend(testCases) | self.testClasses = {} self.numTests = 0 def getMethods(self, klass, prefix): testMethodNames = [ name for name in dir(klass) if name[:len(prefix)] == prefix ] testMethodNames.sort() testMethods = [ getattr(klass, name) for name in testMethodNames if type(getattr(klass, name)) is types.MethodType ] return testMethods | def __init__(self): self.testCases = [] |
testCase = testClass() self.addTestCase(testCase) | methods = self.getMethods(testClass, self.methodPrefix) self.testClasses[testClass] = methods self.numTests += len(methods) | def addTestClass(self, testClass): #print 'adding class %s' % testClass testCase = testClass() self.addTestCase(testCase) |
objects = [ getattr(module, name) for name in dir(module) ] for name in dir(module): | names = dir(module) names.sort() for name in names: | def addModule(self, module): #print 'adding module %s' % module if type(module) is types.StringType: module = reflect.namedModule(module) objects = [ getattr(module, name) for name in dir(module) ] for name in dir(module): obj = getattr(module, name) if type(obj) is types.ClassType and isTestClass(obj): self.addTestCla... |
output.start(len(self.testCases)) for testCase, method in self.testCases: try: testCase.setUp() method() testCase.tearDown() except AssertionError, e: output.reportFailure(testCase, method, sys.exc_info()) except KeyError: break except: output.reportError(testCase, method, sys.exc_info()) else: output.reportSucces... | output.start(self.numTests) testClasses = self.testClasses.keys() testClasses.sort() for testClass in testClasses: testCase = testClass() for method in self.testClasses[testClass]: try: testCase.setUp() method(testCase) testCase.tearDown() except AssertionError, e: output.reportFailure(testClass, method, sys.exc_info()... | def run(self, output): |
def reportFailure(self, testCase, method, exc_info): self.failures.append((testCase, method, exc_info)) | def reportFailure(self, testClass, method, exc_info): self.failures.append((testClass, method, exc_info)) | def reportFailure(self, testCase, method, exc_info): self.failures.append((testCase, method, exc_info)) self.numTests += 1 |
def reportError(self, testCase, method, exc_info): self.errors.append((testCase, method, exc_info)) | def reportError(self, testClass, method, exc_info): self.errors.append((testClass, method, exc_info)) | def reportError(self, testCase, method, exc_info): self.errors.append((testCase, method, exc_info)) self.numTests += 1 |
def reportSuccess(self, testCase, method): | def reportSuccess(self, testClass, method): | def reportSuccess(self, testCase, method): self.numTests += 1 |
def reportFailure(self, testCase, method, exc_info): | def reportFailure(self, testClass, method, exc_info): | def reportFailure(self, testCase, method, exc_info): self.write('F') Reporter.reportFailure(self, testCase, method, exc_info) |
Reporter.reportFailure(self, testCase, method, exc_info) def reportError(self, testCase, method, exc_info): | Reporter.reportFailure(self, testClass, method, exc_info) def reportError(self, testClass, method, exc_info): | def reportFailure(self, testCase, method, exc_info): self.write('F') Reporter.reportFailure(self, testCase, method, exc_info) |
Reporter.reportError(self, testCase, method, exc_info) def reportSuccess(self, testCase, method): | Reporter.reportError(self, testClass, method, exc_info) def reportSuccess(self, testClass, method): | def reportError(self, testCase, method, exc_info): self.write('E') Reporter.reportError(self, testCase, method, exc_info) |
Reporter.reportSuccess(self, testCase, method) def _formatError(self, flavor, (testCase, method, error)): | Reporter.reportSuccess(self, testClass, method) def _formatError(self, flavor, (testClass, method, error)): | def reportSuccess(self, testCase, method): self.write('.') Reporter.reportSuccess(self, testCase, method) |
flavor, method.__name__, testCase.__class__, | flavor, method.__name__, testClass.__name__, | def _formatError(self, flavor, (testCase, method, error)): ret = ("%s\n%s: %s (%s)\n%s\n%s" % (self.DOUBLE_SEPARATOR, flavor, method.__name__, testCase.__class__, self.SEPARATOR, string.join(apply(traceback.format_exception, error)))) return ret |
self.stream.write(format % args) | if args: self.stream.write(format % args) else: self.stream.write(format) | def write(self, format, *args): self.stream.write(format % args) self.stream.flush() |
if __name__ == '__main__': ts = TestSuite() ts.addPackage('twisted.test') ts.run(TextReporter()) | class VerboseTextReporter(TextReporter): def __init__(self, stream=sys.stdout): TextReporter.__init__(self, stream) def reportSuccess(self, testCase, method): self.writeln('%s (%s) ... [OK]', method.__name__, reflect.qual(testCase)) Reporter.reportSuccess(self, testCase, method) def reportFailure(self, testCase, meth... | def stop(self): Reporter.stop(self) self.writeln() for error in self.failures: self.write(self._formatError('FAILURE', error)) for error in self.errors: self.write(self._formatError('ERROR', error)) self.writeln(self.SEPARATOR) self.writeln('Ran %d tests in %.3fs', self.numTests, self.getRunningTime()) self.writeln() s... |
@ivar nickname: Nickname the client will use. @ivar password: Password used to log on to the server. May be C{None}. @ivar realname: Supplied to the server during login as the \"Real name\" or \"ircname\". @ivar userinfo: Sent in reply to a X{USERINFO} CTCP query. If C{None}, no USERINFO reply will be sent. \"This i... | def irc_unknown(self, prefix, command, params): """Implement me!""" raise NotImplementedError | |
From the RFC: | From the RFC:: | def noticed(self, user, channel, message): """Called when I have a notice from a user to me or a channel. |
message from the server. To display, you might want to use | message from the server. To display, you might want to use:: | def receivedMOTD(self, motd): """I recieved a message-of-the-day banner from the server. |
def __init__(self, code, resp, log=None, addresses=None): | def __init__(self, code, resp, log=None, addresses=None, isFatal=False, retry=False): """ @param code: The SMTP response code associated with this error. @param resp: The string response associated with this error. @param log: A string log of the exchange leading up to and including the error. @param isFatal: A boolea... | def __init__(self, code, resp, log=None, addresses=None): self.code = code self.resp = resp self.log = log self.addresses = addresses |
pass | def __init__(self, code, resp, log=None, addresses=None, isFatal=True, retry=True): SMTPClientError.__init__(self, code, resp, log, addresses, isFatal, retry) | def __str__(self): if self.code > 0: res = ["%.3d %s" % (self.code, self.resp)] else: res = [self.resp] if self.log: res.append('') res.append(self.log) return '\n'.join(res) |
pass | def __init__(self, code, resp, log=None, addresses=None, isFatal=True, retry=False): SMTPClientError.__init__(self, code, resp, log, addresses, isFatal, retry) | def __str__(self): if self.code > 0: res = ["%.3d %s" % (self.code, self.resp)] else: res = [self.resp] if self.log: res.append('') res.append(self.log) return '\n'.join(res) |
pass | def __str__(self): if self.code > 0: res = ["%.3d %s" % (self.code, self.resp)] else: res = [self.resp] if self.log: res.append('') res.append(self.log) return '\n'.join(res) | |
self.lastfailed = 0 | def __init__(self, identity, logsize=10): self.identity = identity or '' self.toAddressesResult = [] self.successAddresses = [] self._from = None self.resp = [] self.code = -1 self.lastfailed = 0 self.log = util.LineLog(logsize) | |
"Logging sendLine" self.log.append('>>> ' + line) | if self.debug: self.log.append('>>> ' + line) | def sendLine(self, line): "Logging sendLine" self.log.append('>>> ' + line) basic.LineReceiver.sendLine(self,line) |
self.log.append('<<< ' + line) | def lineReceived(self, line): why = None | |
self.code = -1 self.resp = [] return self._failresponse( -1, "Invalid response from SMTP server: %s" % line) | self.sendError(SMTPProtocolError(-1, "Invalid response from SMTP server: %s" % line, self.log.str())) return | def lineReceived(self, line): why = None |
self.lastfailed = 0 elif not self.lastfailed: | else: | def lineReceived(self, line): why = None |
self.lastfailed += 1 else: self.sendLine('QUIT') self._expected = xrange(0,1000) self._okresponse = self.smtpState_disconnect self.lastfailed = 0 | def lineReceived(self, line): why = None | |
return SMTPConnectError(code, resp, str(self.log)) | self.sendError(SMTPConnectError(code, resp, self.log.str())) | def smtpConnectionFailed(self, code, resp): return SMTPConnectError(code, resp, str(self.log)) |
return SMTPProtocolError(code, resp, str(self.log)) return self.smtpState_msgSent(code, resp) | self.sendError(SMTPProtocolError(code, resp, self.log.str())) else: self.smtpState_msgSent(code, resp) | def smtpTransferFailed(self, code, resp): if code < 0: # protocol error return SMTPProtocolError(code, resp, str(self.log)) return self.smtpState_msgSent(code, resp) |
self.sendLine('QUIT') self._expected = xrange(0,1000) self._okresponse = self.smtpState_disconnect | self._disconnectFromServer() | def smtpState_from(self, code, resp): self._from = self.getMailFrom() self._failresponse = self.smtpTransferFailed if self._from is not None: self.sendLine('MAIL FROM:%s' % quoteaddr(self._from)) self._expected = [250] self._okresponse = self.smtpState_to else: self.sendLine('QUIT') self._expected = xrange(0,1000) self... |
return self.smtpState_msgSent(-1,'No recipients accepted') | return self.smtpState_msgSent(code,'No recipients accepted') | def smtpState_toOrData(self, code, resp): if self.lastAddress is not None: self.toAddressesResult.append((self.lastAddress, code, resp)) if code in SUCCESS: self.successAddresses.append(self.lastAddress) try: self.lastAddress = self.toAddresses.next() except StopIteration: if self.successAddresses: self.sendLine('DATA'... |
self.authenticators = {} | self.authenticators = [] | def __init__(self, secret, contextFactory=None, *args, **kw): SMTPClient.__init__(self, *args, **kw) self.authenticators = {} self.secret = secret self.context = contextFactory self.tlsMode = False |
self.authenticators[auth.getName().upper()] = auth | self.authenticators.append(auth) | def registerAuthenticator(self, auth): self.authenticators[auth.getName().upper()] = auth |
self.sendLine('EHLO ' + self.identity) | def esmtpState_ehlo(self, code, resp): self.sendLine('EHLO ' + self.identity) self._expected = SUCCESS | |
log.msg("TLS required but not available: closing connection") self.sendLine('QUIT') self._expected = xrange(0, 1000) self._okresponse = self.smtpState_disconnect | self.esmtpTLSRequired() | def tryTLS(self, code, resp, items): if self.context and 'STARTTLS' in items: self._expected = [220] self._okresponse = self.esmtpState_starttls self.sendLine('STARTTLS') elif self.requireTransportSecurity: self.tlsMode = False log.msg("TLS required but not available: closing connection") self.sendLine('QUIT') self._ex... |
self.transport.startTLS(self.context) self.tlsMode = True """Send another EHLO once TLS has been started to get the TLS / AUTH schemes""" | try: self.transport.startTLS(self.context) self.tlsMode = True except: log.err() self.esmtpTLSFailed(451) | def esmtpState_starttls(self, code, resp): self.transport.startTLS(self.context) self.tlsMode = True |
tmpSchemes = {} | def authenticate(self, code, resp, items): if self.secret and items.get('AUTH'): schemes = items['AUTH'].split() | |
if s.upper() in self.authenticators: self._authinfo = self.authenticators[s] """Special condition handled""" if s.upper() == "PLAIN": | tmpSchemes[s.upper()] = 1 for a in self.authenticators: auth = a.getName().upper() if auth in tmpSchemes: self._authinfo = a if auth == "PLAIN": | def authenticate(self, code, resp, items): if self.secret and items.get('AUTH'): schemes = items['AUTH'].split() |
self.sendLine('AUTH ' + s + ' ' + challenge) | self.sendLine('AUTH ' + auth + ' ' + challenge) | def authenticate(self, code, resp, items): if self.secret and items.get('AUTH'): schemes = items['AUTH'].split() |
self.sendLine('AUTH ' + s) | def authenticate(self, code, resp, items): if self.secret and items.get('AUTH'): schemes = items['AUTH'].split() | |
self._authinfo = self.authenticators[s] | self._failresponse = self.esmtpAUTHServerError self.sendLine('AUTH ' + auth) | def authenticate(self, code, resp, items): if self.secret and items.get('AUTH'): schemes = items['AUTH'].split() |
log.msg("Authentication required but none available: closing connection") self.sendLine('QUIT') self._expected = xrange(0, 1000) self._okresponse = self.smtpState_disconnect | self.esmtpAUTHRequired() | def authenticate(self, code, resp, items): if self.secret and items.get('AUTH'): schemes = items['AUTH'].split() |
self._failresponse = self.smtpState_disconnect | self._failresponse = self.esmtpAUTHDeclined | def _esmtpState_plainAuth(self, code, resp): self._okresponse = self.smtpState_from self._failresponse = self.smtpState_disconnect self._expected = [235] challenge = encode_base64(self._authinfo.challengeResponse(self.secret, 2), eol="") self.sendLine('AUTH PLAIN ' + challenge) |
self._okresponse = self.smtpState_disconnect self._failresponse = self.smtpState_disconnect | self._okresponse = self.esmtpAUTHMalformedChallenge self._failresponse = self.esmtpAUTHMalformedChallenge | def _authResponse(self, auth, challenge): try: challenge = base64.decodestring(challenge) |
self._failresponse = self.smtpState_disconnect | def _authResponse(self, auth, challenge): try: challenge = base64.decodestring(challenge) | |
if numOk: errlog.append(str(log)) | errlog.append(log.str()) | def sentMail(self, code, resp, numOk, addresses, log): self.factory.sendFinished = 1 if code not in SUCCESS: # Failure errlog = [] for addr, acode, aresp in addresses: if code not in SUCCESS: errlog.append("%s: %03d %s" % (addr, acode, aresp)) |
def clientConnectionFailed(self, connector, error): self.result.errback(error) def clientConnectionLost(self, connector, error): | def clientConnectionFailed(self, connector, err): self._processConnectionError(connector, err) def clientConnectionLost(self, connector, err): self._processConnectionError(connector, err) def _processConnectionError(self, connector, err): | def clientConnectionFailed(self, connector, error): self.result.errback(error) |
connector.connect() | log.msg("SMTP Client retrying server. Retry: %s" % -self.retries) connector.connect() self.retries += 1 | def clientConnectionLost(self, connector, error): # if email wasn't sent, try again if self.retries < self.sendFinished <= 0: connector.connect() # reconnect to SMTP server elif self.sendFinished <= 0: self.result.errback(error) self.sendFinished -= 1 |
self.result.errback(error) self.sendFinished -= 1 | if err.check(error.ConnectionDone): err.value = SMTPConnectError(-1, "Unable to connect to server.") self.result.errback(err.value) | def clientConnectionLost(self, connector, error): # if email wasn't sent, try again if self.retries < self.sendFinished <= 0: connector.connect() # reconnect to SMTP server elif self.sendFinished <= 0: self.result.errback(error) self.sendFinished -= 1 |
p = self.protocol(self.username, self.password, self._contextFactory, self.domain, len(self.toEmail)*2+2) | p = self.protocol(self.username, self.password, self._contextFactory, self.domain, self.nEmails*2+2) | def buildProtocol(self, addr): p = self.protocol(self.username, self.password, self._contextFactory, self.domain, len(self.toEmail)*2+2) p.heloFallback = self._heloFallback p.requireAuthentication = self._requireAuthentication p.requireTransportSecurity = self._requireTransportSecurity p.factory = self return p |
def getData(self): | def getData(self, request): | def getData(self): """Get a random quote from the quotefile. """ return self._quoter.getQuote() |
ref.modelChanged(changed) | retVal.append(ref.modelChanged(changed)) | def notify(self, changed=None): """ Notify all views that something was changed on me. Passing a dictionary of {'attribute': 'new value'} in changed will pass this dictionary to the view for increased performance. If you don't want to do this, don't, and just use the traditional MVC paradigm of querying the model for t... |
ref.modelChanged(changed) | retVal.append(ref.modelChanged(changed)) return retVal | def notify(self, changed=None): """ Notify all views that something was changed on me. Passing a dictionary of {'attribute': 'new value'} in changed will pass this dictionary to the view for increased performance. If you don't want to do this, don't, and just use the traditional MVC paradigm of querying the model for t... |
y,mon,d,h,min, i,g,no,re = time.localtime(time.time()) return ("%0.4d/%0.2d/%0.2d %0.2d:%0.2d [%s] " % (y,mon,d,h,min , self.logPrefix())) | y,mon,d,h,min, i,g,no,daylight = time.localtime(time.time()) return ("%0.4d/%0.2d/%0.2d %0.2d:%0.2d %s [%s] " % (y,mon,d,h,min,time.tzname[daylight], self.logPrefix())) | def __prefix(self): y,mon,d,h,min, i,g,no,re = time.localtime(time.time()) return ("%0.4d/%0.2d/%0.2d %0.2d:%0.2d [%s] " % (y,mon,d,h,min , self.logPrefix())) |
gtk.idle_remove(_simtag) | gtk.timeout_remove(_simtag) | def simulate(self): """Run simulation loops and reschedule callbacks. """ global _simtag if _simtag is not None: gtk.idle_remove(_simtag) self.iterate() _simtag = gtk.idle_add(self.simulate) |
_simtag = gtk.idle_add(self.simulate) | timeout = min(self.timeout(), 0.1) if timeout is None: timeout = 0.1 _simtag = gtk.timeout_add(timeout * 1010, self.simulate) | def simulate(self): """Run simulation loops and reschedule callbacks. """ global _simtag if _simtag is not None: gtk.idle_remove(_simtag) self.iterate() _simtag = gtk.idle_add(self.simulate) |
def connectionLost(self): | def connectionLost(self, reason): | def connectionLost(self): print "Lost a client!" self.factory.clients.remove(self) |
while (not 'cftp> ' in self.processProtocol.buffer) and (time.time() < timeout): | while (self.processProtocol.buffer.find('cftp> ') == -1) and (time.time() < timeout): | def _getCmdResult(self, cmd): self.processProtocol.clearBuffer() self.processProtocol.transport.write(cmd+'\n') timeout = time.time() + 5 while (not 'cftp> ' in self.processProtocol.buffer) and (time.time() < timeout): reactor.iterate(0.1) self.failIf(time.time() > timeout, "timeout") if self.processProtocol.buffer.sta... |
def testCompareFileConents(self): | def testCompareFileContents(self): | def testCompareFileConents(self): def gotFname(fname): contents = file(fname, 'r').read() self.assertEquals(contents, 'Test contents') return self.uploadFile('FileNameOne', 'myfilename', 'text/plain', 'Test contents').addCallback( self.fileNameFromResponse ).addCallback(gotFname) |
PORT=9000 | port = reactor.listenTCP(0, f) PORT = port.getHost()[2] | def testStopTrying(self): f = Factory() f.protocol = In f.connections = 0 f.allMessages = [] |
reactor.listenTCP(PORT, f) | def testStopTrying(self): f = Factory() f.protocol = In f.connections = 0 f.allMessages = [] | |
element.addChild(jellier.jellyToNode(self.__dict__)) | element.appendChild(jellier.jellyToNode(self.__dict__)) | def jellyToDOM(self, jellier, element): element.setAttribute("marmalade:version", str(self.jellyDOMVersion)) method = getattr(self, "jellyToDOM_%s" % self.jellyDOMVersion, None) if method: method(jellier, element) else: element.addChild(jellier.jellyToNode(self.__dict__)) |
self.assertEquals(m.code, 501) | self.assertEquals(m.code, 401) | def testFailedBasicAuthentication(self): self.addPortal() |
defer.Deferred.debug = True failure.startDebugMode() | def runReactorWithLogging(config, oldstdout, oldstderr): from twisted.internet import reactor, defer try: if config['profile']: if sys.version_info[:2] > (2, 2) and not config['nothotshot']: runWithHotshot(reactor, config) else: runWithProfiler(reactor, config) elif config['debug']: defer.Deferred.debug = True failure.... | |
['debug', 'b', "run the application in the Python Debugger " "(implies nodaemon), sending SIGUSR2 will drop into debugger"], | def reportProfile(report_profile, name): if not report_profile: return if name: from twisted.python.dxprofile import report log.msg("Sending DXP stats...") report(report_profile, name) log.msg("DXP stats sent.") else: log.err("--report-profile specified but application has no " "name (--appname unspecified)") |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.