rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
def opt_trialdebug(self, arg): """turn on trial's internal debugging flags""" try: self._logObserver = _DebugLogObserver(arg) except LogError, e: raise usage.UsageError, "%s not a valid debugging channel" % (e.args[0]) | def opt_trialdebug(self, arg): """turn on trial's internal debugging flags""" try: self._logObserver = _DebugLogObserver(arg) except LogError, e: raise usage.UsageError, "%s not a valid debugging channel" % (e.args[0]) | |
self._manholeWindow.set_title("Manhole - %s:%s" % (peer[1], peer[2])) | self._manholeWindow.set_title("Manhole - %s" % (peer)) | def _cbLogin(self, perspective): peer = perspective.broker.transport.getPeer() self.output.append("Connected to %s\n" % (peer,), "local") perspective.notifyOnDisconnect(self._cbDisconnected) self._manholeWindow.set_title("Manhole - %s:%s" % (peer[1], peer[2])) return perspective |
class History(object): _hist = None active = False __debug = False def __init__(self): from sets import Set self._hist = [] self._set = Set() self._idx = 0 def add(self, text): self._hist.insert(0, text) _state = property(lambda self: '_hist: %r, _idx: %s, active: %r' % (repr(self._hist), self._idx, self.active)) d... | class History: def __init__(self, maxhist=10000): self.ringbuffer = [''] self.maxhist = maxhist self.histCursor = 0 def append(self, htext): self.ringbuffer.insert(-1, htext) if len(self.ringbuffer) > self.maxhist: self.ringbuffer.pop(0) self.histCursor = len(self.ringbuffer) - 1 self.ringbuffer[-1] = '' def move(sel... | def _scrollDown(self, *unused): self.textView.scroll_to_iter(self.buffer.get_end_iter(), 0, True, 1.0, 1.0) self._willScroll = None return False |
getattr(self, 'key_%s' % ksym, lambda *a, **kw: None)(entry, event) | rvalue = getattr( self, 'key_%s' % ksym, lambda *a, **kw: None)(entry, event) | def _on_key_press_event(self, entry, event): stopSignal = False ksym = self.rkeymap.get(event.keyval, None) |
return False | return rvalue | def _on_key_press_event(self, entry, event): stopSignal = False ksym = self.rkeymap.get(event.keyval, None) |
self.history.add(text) self.history.reset() | self.history.append(text) | def key_Return(self, entry, event): text = self.getText() # Figure out if that Return meant "next line" or "execute." try: c = code.compile_command(text) except SyntaxError, e: # This could conceivably piss you off if the client's python # doesn't accept keywords that are known to the manhole's # python. point = buffer... |
entry.emit_stop_by_name("key_press_event") | return True | def key_Return(self, entry, event): text = self.getText() # Figure out if that Return meant "next line" or "execute." try: c = code.compile_command(text) except SyntaxError, e: # This could conceivably piss you off if the client's python # doesn't accept keywords that are known to the manhole's # python. point = buffer... |
pass | return False | def key_Return(self, entry, event): text = self.getText() # Figure out if that Return meant "next line" or "execute." try: c = code.compile_command(text) except SyntaxError, e: # This could conceivably piss you off if the client's python # doesn't accept keywords that are known to the manhole's # python. point = buffer... |
def key_ctrl_p(self, entry, event): log.msg(input='C-p key event') hist = self.history.prev() text = self.getText() print "hist: %s, text: %s" % (hist, text) self.setText(hist) | def key_Up(self, entry, event): textbuffer = self.textView.get_buffer() if textbuffer.get_iter_at_mark(textbuffer.get_insert()).get_line() == 0: self.history.histup(textbuffer) return True | def key_Return(self, entry, event): text = self.getText() # Figure out if that Return meant "next line" or "execute." try: c = code.compile_command(text) except SyntaxError, e: # This could conceivably piss you off if the client's python # doesn't accept keywords that are known to the manhole's # python. point = buffer... |
def key_ctrl_n(self, entry, event): log.msg(input='C-n key event') text = self.getText() if not self.history.active and text: return False hist = self.history.next() self.clear() self.setText(hist) | def key_Down(self, entry, event): textbuffer = self.textView.get_buffer() if textbuffer.get_iter_at_mark(textbuffer.get_insert()).get_line() == ( textbuffer.get_line_count() - 1): self.history.histdown(textbuffer) return True | def key_ctrl_n(self, entry, event): log.msg(input='C-n key event') |
def key_ctrl_shift_F5(self, entry, event): if self.__debug: log.msg(self.history._state) | def key_ctrl_shift_F9(self, entry, event): if self.__debug: import pdb; pdb.set_trace() | |
def testAdd(self): | def testAppend(self): | def testAdd(self): v = iovec.iovec() for s in [chr(i + ord('a')) * i for i in range(1, 11)]: v.add(s) |
for s in [chr(i + ord('a')) * i for i in range(1, 11)]: v.add(s) | for s in [chr(i + ord('a')) * i for i in range(1, HARD_CHUNK_SIZE+1)]: v.append(s) self.assertEquals(arith(HARD_CHUNK_SIZE), v.bytes) | def testAdd(self): v = iovec.iovec() for s in [chr(i + ord('a')) * i for i in range(1, 11)]: v.add(s) |
for s in [chr(i + ord('a')) * i for i in range(1, 11)]: v.add(s) | for s in [chr(i + ord('a')) * i for i in range(1, HARD_CHUNK_SIZE+1)]: v.append(s) self.assertEquals(arith(HARD_CHUNK_SIZE), v.bytes) | def testWriteToFile(self): v = iovec.iovec() for s in [chr(i + ord('a')) * i for i in range(1, 11)]: v.add(s) f = tempfile.TemporaryFile('w+') self.assertEquals(55, v.write(f)) f.seek(0, 0) self.assertEquals(f.read(), ''.join([chr(i + ord('a')) * i for i in range(1, 11)])) |
self.assertEquals(55, v.write(f)) | self.assertEquals(arith(HARD_CHUNK_SIZE), v.write(f)) self.assertEquals(0, v.bytes) | def testWriteToFile(self): v = iovec.iovec() for s in [chr(i + ord('a')) * i for i in range(1, 11)]: v.add(s) f = tempfile.TemporaryFile('w+') self.assertEquals(55, v.write(f)) f.seek(0, 0) self.assertEquals(f.read(), ''.join([chr(i + ord('a')) * i for i in range(1, 11)])) |
self.assertEquals(f.read(), ''.join([chr(i + ord('a')) * i for i in range(1, 11)])) | self.assertEquals(f.read(), ''.join([chr(i + ord('a')) * i for i in range(1, HARD_CHUNK_SIZE+1)])) | def testWriteToFile(self): v = iovec.iovec() for s in [chr(i + ord('a')) * i for i in range(1, 11)]: v.add(s) f = tempfile.TemporaryFile('w+') self.assertEquals(55, v.write(f)) f.seek(0, 0) self.assertEquals(f.read(), ''.join([chr(i + ord('a')) * i for i in range(1, 11)])) |
for s in [chr(i + ord('a')) * i for i in range(1, 11)]: v.add(s) | for s in [chr(i + ord('a')) * i for i in range(1, HARD_CHUNK_SIZE+1)]: v.append(s) self.assertEquals(arith(HARD_CHUNK_SIZE), v.bytes) | def testWriteToFileDescriptor(self): v = iovec.iovec() for s in [chr(i + ord('a')) * i for i in range(1, 11)]: v.add(s) f = tempfile.TemporaryFile('w+') self.assertEquals(55, v.write(f.fileno())) f.seek(0, 0) self.assertEquals(f.read(), ''.join([chr(i + ord('a')) * i for i in range(1, 11)])) |
self.assertEquals(55, v.write(f.fileno())) | self.assertEquals(arith(HARD_CHUNK_SIZE), v.write(f.fileno())) | def testWriteToFileDescriptor(self): v = iovec.iovec() for s in [chr(i + ord('a')) * i for i in range(1, 11)]: v.add(s) f = tempfile.TemporaryFile('w+') self.assertEquals(55, v.write(f.fileno())) f.seek(0, 0) self.assertEquals(f.read(), ''.join([chr(i + ord('a')) * i for i in range(1, 11)])) |
self.assertEquals(f.read(), ''.join([chr(i + ord('a')) * i for i in range(1, 11)])) | self.assertEquals(f.read(), ''.join([chr(i + ord('a')) * i for i in range(1, HARD_CHUNK_SIZE+1)])) | def testWriteToFileDescriptor(self): v = iovec.iovec() for s in [chr(i + ord('a')) * i for i in range(1, 11)]: v.add(s) f = tempfile.TemporaryFile('w+') self.assertEquals(55, v.write(f.fileno())) f.seek(0, 0) self.assertEquals(f.read(), ''.join([chr(i + ord('a')) * i for i in range(1, 11)])) |
for s in ['x' * i for i in range(100)]: v.add(s) | for s in ['x' * i for i in range(1, 101)]: v.append(s) self.assertEquals(v.bytes, arith(100)) | def testIllegalWrites(self): v = iovec.iovec() for s in ['x' * i for i in range(100)]: v.add(s) |
bf.write('Chapter("%s", None)\r\n' % inputFilename) | bf.write('Chapter(r"%s", None)\r\n' % inputFilename) | def test_book(self): fn = sp('lore_test_book.book') inputFilename = sp('lore_index_test.xhtml') |
self.assertEquals("{'indexFilename': None, 'chapters': [('%s', None)]}" % inputFilename, str(book.__dict__)) | expected = {'indexFilename': None, 'chapters': [(inputFilename, None)], } dct = book.__dict__ for k in dct: self.assertEquals(dct[k], expected[k]) | def test_book(self): fn = sp('lore_test_book.book') inputFilename = sp('lore_index_test.xhtml') |
bf.write('Chapter("%s", None)\n' % inputFilename) | bf.write('Chapter(r"%s", None)\n' % inputFilename) | def test_runningLore(self): options = lore.Options() templateFilename = sp('template.tpl') inputFilename = sp('lore_index_test.xhtml') indexFilename = 'theIndexFile' |
bf.write('Chapter("%s", None)\n' % inputFilename) bf.write('Chapter("%s", None)\n' % inputFilename2) | bf.write('Chapter(r"%s", None)\n' % inputFilename) bf.write('Chapter(r"%s", None)\n' % inputFilename2) | def test_runningLoreMultipleFiles(self): templateFilename = sp('template.tpl') inputFilename = sp('lore_index_test.xhtml') inputFilename2 = sp('lore_index_test2.xhtml') indexFilename = 'theIndexFile' |
test, failure = self.errorInfo[selected] s = StringIO.StringIO() failure.printTraceback(s) tracebackText = s.getvalue() | test, error = self.errorInfo[selected] if isinstance(error, Failure): s = StringIO.StringIO() error.printTraceback(s) tracebackText = s.getvalue() else: tracebackLines = apply(traceback.format_exception, error + (10,)) tracebackText = string.join(tracebackLines,'') | def showSelectedError(self): selection = self.errorListbox.curselection() if not selection: return selected = int(selection[0]) txt = self.errorListbox.get(selected) window = tk.Toplevel(self.root) window.title(txt) window.protocol('WM_DELETE_WINDOW', window.quit) test, failure = self.errorInfo[selected] s = StringIO.S... |
i = reactor.callLater(0.5, self._callback, 1, a=1) | def bad(): raise RuntimeError, "this shouldn't have been called" | |
def isclass(k): return isinstance(k, (types.ClassType, types.TypeType)) classes = [val for name, val in inspect.getmembers(module, isclass)] return dsu(filter(ITestCase.implementedBy, classes), self.sorter) | classes = [] for name, val in inspect.getmembers(module): try: if ITestCase.implementedBy(val): classes.append(val) except TypeError: pass return dsu(classes, self.sorter) | def isclass(k): ## XXX -- work around. remove ASAP. ## inspect.isclass checks for ClassType and then if __bases__ ## is an attribute. ## t.conch.insults.text.CharacterAttributes has a (buggy?) __getattr__ ## which returns objects for any given attribute. Hence it has ## __bases__, hence, inspect.isclass believes insta... |
sslState = self.socket.state_string() | def writeSomeData(self, data): # this sslState thing is the most HORRIBLE THING EVER # ask itamar about it if you have questions sslState = self.socket.state_string() try: return Connection.writeSomeData(self, data) except SSL.WantWriteError: return 0 except SSL.WantReadError: if self.socket.state_string() == sslState:... | |
if self.socket.state_string() == sslState: self.stopWriting() | def writeSomeData(self, data): # this sslState thing is the most HORRIBLE THING EVER # ask itamar about it if you have questions sslState = self.socket.state_string() try: return Connection.writeSomeData(self, data) except SSL.WantWriteError: return 0 except SSL.WantReadError: if self.socket.state_string() == sslState:... | |
newEnv = extendEnv(VAR, self.env, func_map(lambda x, env=self.env: cons(car(x), evalExp(cadr(x), env)), bindings)) | newEnv = extendEnv(VAR, self.env, func_map(lambda x, env=self.env: cons(car(x), evalExp(cdr(x), env)), bindings)) | def __call__(self, *args): bindings = [] i = 0 crap = self.llist while crap: var = car(crap) bindings = cons(cons(var, args[i]), bindings) i = i + 1 crap = cdr(crap) |
um.error.raiseException() | error.raiseException() | def _setUpSkipTests(tm): tm.skip = self.skip |
if _fixedClasses.has_key(klass): return | def fixClassImplements(klass): """Switch class from __implements__.""" if hasattr(klass, "__implements__") and isinstance(klass.__implements__, (tuple, MetaInterface)): warnings.warn("Please use implements(), not __implements__ for class %s" % klass, DeprecationWarning) declarations.classImplementsOnly(klass, *tupleTre... | |
_fixedClasses[klass] = 1 | def fixClassImplements(klass): """Switch class from __implements__.""" if hasattr(klass, "__implements__") and isinstance(klass.__implements__, (tuple, MetaInterface)): warnings.warn("Please use implements(), not __implements__ for class %s" % klass, DeprecationWarning) declarations.classImplementsOnly(klass, *tupleTre... | |
def _hook(iface, ob): return getAdapter(ob, iface, default=None, persist=False) | def _hook(iface, ob, lookup=_theAdapterRegistry.lookup1): factory = lookup(declarations.providedBy(ob), iface) if factory is None: return None else: return factory(ob) | def _hook(iface, ob): return getAdapter(ob, iface, default=None, persist=False) |
__implements__ attribute will be scanned. | provided interfaces will be scanned. | def addComponent(self, component, ignoreClass=0, registry=None): """ Add a component to me, for all appropriate interfaces. |
adapter.multiComponent and hasattr(adapter, '__implements__')): | adapter.multiComponent): | def getComponent(self, interface, registry=None, default=None): """Create or retrieve an adapter for the given interface. |
if len(args)==1 and not kw: | if not args or (len(args)==1 and not kw): | def parse(description, factory, default=None): """Parse a description of a reliable virtual circuit server @type description: C{str} @type factory: C{twisted.internet.interfaces.IProtocolFactory} @type default: C{str} or C{None} @rtype: C{tuple} @return: a tuple of string, tuple and dictionary. The string is the name ... |
gatewayname,contact,state=self.list.get(ACTIVE) self.list.delete(ACTIVE) self.im.removeContact(self.im.gateways[gatewayname],contact) | user=self.box.curselection() if not user: return username=user.node.user gateway=user.parent.parent.node.gateway self.box.remove(user) self.im.removeContact(gateway,username) | def removeContact(self): gatewayname,contact,state=self.list.get(ACTIVE) self.list.delete(ACTIVE) self.im.removeContact(self.im.gateways[gatewayname],contact) |
gatewayname,user,state=self.list.get(ACTIVE) if gatewayname!=gateway.name: | user=self.box.curselection() if not user: return username=user.node.user gateway2=user.parent.parent.node.gateway if gateway2!=gateway: | def runExtra(self,gateway,func): gatewayname,user,state=self.list.get(ACTIVE) if gatewayname!=gateway.name: user=None state=None func(self.im,gateway,user,state) |
if u==user: return 1 | if type(s)==type(""): if u==user: return 1 else: if u.hasUser(user): return 1 | def hasUser(self,user): for u,s in self.users: if u==user: return 1 return 0 |
del imclientt.groups[strgate+value.name] | del imclient.groups[strgate+value.name] | def handleError(gateway,event_name,message): global imclient strgate=str(gateway) for key,value in imclient.conversations.items(): if key[:len(strgate)]==strgate: value.destroy() imclient.endConversation(gateway,value.target) for key,value in imclient.groups.items(): if key[:len(strgate)]==strgate: value.destroy() del ... |
thingummy = deferGenerator(thingummy) | thingummy = deferredGenerator(thingummy) | def thingummy(): thing = waitForDeferred(makeSomeRequestResultingInDeferred()) yield thing thing = thing.getResult() print thing #the result! hoorj! |
new set on that message. | now set on that message. | def flagsChanged(self, newFlags): """Indicates that the flags of one or more messages have changed. |
node.tagName += node.getAttribute('class') | node.tagName += '_'+node.getAttribute('class') | def visitNode_span(self, node): if not node.hasAttribute('class'): return self.visitNodeDefault(node) node.tagName += node.getAttribute('class') self.visitNode(node) |
self.assert_(0 < self._resetcallbackTime - start - 0.5 < 0.2) self.assert_(0 < self._delaycallbackTime - start - 0.8 < 0.2) | self.assert_(-0.1 < self._resetcallbackTime - start - 0.5 < 0.1) self.assert_(-0.1 < self._delaycallbackTime - start - 0.8 < 0.1) | def testCallLaterDelayAndReset(self): self._resetcallbackTime = None self._delaycallbackTime = None ireset = reactor.callLater(0.5, self._resetcallback) idelay = reactor.callLater(0.5, self._delaycallback) start = time.time() # chug a little before delaying while time.time() - start < 0.2: reactor.iterate(0.01) ireset.... |
self.session = ISession(self.avatar) | if not self.session: self.session = ISession(self.avatar) | def request_pty_req(self, data): self.session = ISession(self.avatar) term, windowSize, modes = parseRequest_pty_req(data) log.msg('pty request: %s %s' % (term, windowSize)) try: self.session.getPty(term, windowSize, modes) except: log.err() return 0 else: return 1 |
while len(f.allMessages) != 2 and (time.time() < now + 5): | while len(f.allMessages) != 2 and (time.time() < now + 10): | def testStopTrying(self): f = Factory() f.protocol = In f.connections = 0 f.allMessages = [] |
self.request.stopConsuming() self.request.finish() | self.request.unregisterProducer() reactor.callLater(0, self.request.finish) | def stopProducing(self): self.request.stopConsuming() self.request.finish() self.request = None |
self.file.close() self.file = None | def connectionLost(self): if (self.action == 'STOR') and (self.file): self.file.close() self.file = None self.pi.reply('fileok') self.pi.queuedfile = None self.action = None self.dtpPort.loseConnection() | |
self.pi.queuedfile = None | elif self.file is not None: if self.file.tell() == self.filesize: self.pi.reply('fileok') else: self.pi.reply('getabort') self.file.close() self.file = None self.pi.queuedfile = None | def connectionLost(self): if (self.action == 'STOR') and (self.file): self.file.close() self.file = None self.pi.reply('fileok') self.pi.queuedfile = None self.action = None self.dtpPort.loseConnection() |
if self.file is not None: if self.file.tell() == self.filesize: self.pi.reply('fileok') else: self.pi.reply('getabort') self.file.close() self.file = None self.pi.queuedfile = None | def finishRETR(self): """Disconnect, and clean up a RETR Called by producer when the transfer is done """ # Has _two_ checks if it is run when it is not connected; this logic # should be somewhere else. if self.file is not None: if self.file.tell() == self.filesize: self.pi.reply('fileok') else: self.pi.reply('getabort... | |
factory = RPCFactory(service, rpcConf[service.name], rpcVersions) | factory = RPCFactory(service, rpcConf.services[name], rpcVersions) | def main(options=None): # Parse options, read various config files if not options: options = InetdOptions() options.parseOptions() conf = inetdconf.InetdConf() conf.parseFile(open(options['file'])) rpcConf = inetdconf.RPCServicesConf() try: rpcConf.parseFile() except: # We'll survive even if we can't read /etc/rpc lo... |
p = app.listenTCP(service.port, factory) | p = reactor.listenTCP(service.port, factory) | def main(options=None): # Parse options, read various config files if not options: options = InetdOptions() options.parseOptions() conf = inetdconf.InetdConf() conf.parseFile(open(options['file'])) rpcConf = inetdconf.RPCServicesConf() try: rpcConf.parseFile() except: # We'll survive even if we can't read /etc/rpc lo... |
p = app.listenUDP(service.port, factory) | p = reactor.listenUDP(service.port, factory) | def main(options=None): # Parse options, read various config files if not options: options = InetdOptions() options.parseOptions() conf = inetdconf.InetdConf() conf.parseFile(open(options['file'])) rpcConf = inetdconf.RPCServicesConf() try: rpcConf.parseFile() except: # We'll survive even if we can't read /etc/rpc lo... |
return udp.Port(self, port, factory, interface, maxPacketSize) | return udp.Port(port, factory, interface, maxPacketSize) | def listenUDP(self, port, factory, interface='', maxPacketSize=8192): """See twisted.internet.interfaces.IReactorUDP.listenUDP """ return udp.Port(self, port, factory, interface, maxPacketSize) |
cmd.deferred.addBoth(lambda x, m=_mutable: m[0].disconnect() or x) | cmd.deferred.addBoth(lambda x, m=_mutable: m[0] and m[0].disconnect() or x) | def clientConnectionFailed(self, connector, reason): self.protocol.connectionFailed() |
result = _Wait.wait(d, timeout) | result = _wait(d, timeout) | def deferredResult(d, timeout=None): """ Waits for a Deferred to arrive, then returns or throws an exception, based on the result. """ result = _Wait.wait(d, timeout) if isinstance(result, failure.Failure): raise result else: return result |
result = _Wait.wait(d, timeout) | result = _wait(d, timeout) | def deferredError(d, timeout=None): """ Waits for deferred to fail, and it returns the Failure. If the deferred succeeds, raises FailTest. """ result = _Wait.wait(d, timeout) if isinstance(result, failure.Failure): return result else: from twisted.trial import unittest raise unittest.FailTest, "Deferred did not fail: ... |
class _Wait(object): _active = 0 def wait(cls, d, timeout=None): from twisted.trial import unittest, itrial from twisted.internet import reactor if cls._active >= 1: raise WaitIsNotReentrantError, REENTRANT_WAIT_ERROR_MSG cls._active += 1 | def _wait(d, timeout=None, running=[]): from twisted.trial import unittest, itrial from twisted.internet import reactor if running: raise WaitIsNotReentrantError, REENTRANT_WAIT_ERROR_MSG running.append(None) try: assert isinstance(d, defer.Deferred), "first argument must be a deferred!" results = [] def append(any):... | def spinWhile(f, timeout=4.0, msg="f did not return false before timeout"): """spin the reactor while condition returned by f() == True or until timeout seconds have elapsed i.e. spin until f() is False """ assert callable(f) from twisted.internet import reactor now = time.time() stop = now + timeout while f(): if time... |
assert isinstance(d, defer.Deferred), "first argument must be a deferred!" results = [] def append(any): results.append(any) d.addBoth(append) if results: return results[0] def crash(ign): reactor.crash() d.addBoth(crash) if timeout is None: timeoutCall = None | reactor.run() finally: del reactor.stop if timeoutCall is not None: if timeoutCall.active(): timeoutCall.cancel() | def wait(cls, d, timeout=None): from twisted.trial import unittest, itrial from twisted.internet import reactor |
timeoutCall = reactor.callLater(timeout, reactor.crash) def stop(): reactor.crash() reactor.stop = stop try: reactor.run() finally: del reactor.stop if timeoutCall is not None: if timeoutCall.active(): timeoutCall.cancel() else: raise defer.TimeoutError() if results: return results[0] raise KeyboardInterrupt() fi... | raise defer.TimeoutError() if results: return results[0] raise KeyboardInterrupt() finally: results = None running.pop() | def crash(ign): reactor.crash() |
r = _Wait.wait(d, timeout) | r = _wait(d, timeout) | def wait(d, timeout=DEFAULT_TIMEOUT, useWaitError=False): """Waits (spins the reactor) for a Deferred to arrive, then returns or throws an exception, based on the result. The difference between this and deferredResult is that it actually throws the original exception, not the Failure, so synchronous exception handling ... |
domhelpers.writeNodeData(node, oldio) | latex.getLatexText(node, oldio.write, entities={'lt': '<', 'gt': '>', 'amp': '&'}) | def fontifyPythonNode(node): oldio = cStringIO.StringIO() domhelpers.writeNodeData(node, oldio) oldio = cStringIO.StringIO(oldio.getvalue().strip()+'\n') newio = cStringIO.StringIO() htmlizer.filter(oldio, newio) newio.seek(0) newel = microdom.parse(newio).documentElement newel.setAttribute("class", "python") node.pare... |
new = node.cloneNode(1) | if self.clearNode: new = node.cloneNode(0) else: new = node.cloneNode(1) | def generateDOM(self, request, node): """ @returns: A DOM Node to replace the Node in the template that this Widget handles. This Node is created based on L{tagName}, L{children}, and L{attributes} (You should populate these in L{setUp}, probably). """ if self.become: #print "becoming" become = self.become self.become ... |
id = self['id'] | id = self.attributes.get('id', '') | def setError(self, request, message): """ Convenience method for allowing a Controller to report an error to the user. When this is called, a Widget of class self.errorFactory is instanciated and set to self.become. When generate is subsequently called, self.become will be responsible for mutating the DOM instead of th... |
def getPattern(self, name, default=missingPattern, clone=1): | def getPattern(self, name, default=missingPattern, clone=1, deep=1): | def getPattern(self, name, default=missingPattern, clone=1): """Get a named slot from the incoming template node. Returns a copy of the node and all its children. If there was more than one node with the same slot identifier, they will be returned in a round-robin fashion. """ #print self.templateNode.toxml() if self.s... |
clone = slot.cloneNode(1) | clone = slot.cloneNode(deep) | def getPattern(self, name, default=missingPattern, clone=1): """Get a named slot from the incoming template node. Returns a copy of the node and all its children. If there was more than one node with the same slot identifier, they will be returned in a round-robin fashion. """ #print self.templateNode.toxml() if self.s... |
if self._has_data(data): | if data: | def generateDOM(self, request, node): node = Widget.generateDOM(self, request, node) listHeader = self.getPattern('listHeader', None) listFooter = self.getPattern('listFooter', None) emptyList = self.getPattern('emptyList', None) domhelpers.clearNode(node) if not listHeader is None: node.appendChild(listHeader) data = ... |
def _has_data(self, data): try: return len(data) except (TypeError, AttributeError): return 0 | def generateDOM(self, request, node): node = Widget.generateDOM(self, request, node) listHeader = self.getPattern('listHeader', None) listFooter = self.getPattern('listFooter', None) emptyList = self.getPattern('emptyList', None) domhelpers.clearNode(node) if not listHeader is None: node.appendChild(listHeader) data = ... | |
def _has_data(self, data): return len(data.keys()) | def _has_data(self, data): return len(data.keys()) | |
class ColumnList(List): | class ColumnList(Widget): | def _iterateData(self, parentNode, submodel, data): """ """ currentListItem = 0 keys = data.keys() # Keys may be a tuple, if this is not a true dictionary but a dictionary-like object if hasattr(keys, 'sort'): keys.sort() for key in keys: newNode = self.getPattern('keyedListItem') if not newNode: newNode = self.getPatt... |
List.__init__(self, model, *args, **kwargs) | Widget.__init__(self, model, *args, **kwargs) | def __init__(self, model, columns=1, start=0, end=0, *args, **kwargs): List.__init__(self, model, *args, **kwargs) self.columns = columns self.start = start self.end = end |
def generateDOM(self, request, node): node = Widget.generateDOM(self, request, node) domhelpers.clearNode(node) | def setUp(self, request, node, data): pattern = self.getPattern('columnListRow', clone=0) | def generateDOM(self, request, node): node = Widget.generateDOM(self, request, node) domhelpers.clearNode(node) |
if listSize > len(self.getData()): listSize = len(self.getData()) else: listSize = len(self.getData()) | if listSize > len(data): listSize = len(data) else: listSize = len(data) | def generateDOM(self, request, node): node = Widget.generateDOM(self, request, node) domhelpers.clearNode(node) |
newNode = self.getPattern('item') | newNode = self.getPattern('item', _RAISE) | def _iterateData(self, parentNode, submodel, data): """ """ currentListItem = 0 for key in data.keys(): if not newNode: newNode = self.getPattern('item') if newNode: warnings.warn("itemOf= is deprecated, " "please use listItemOf instead", DeprecationWarning) appendModel(newNode, key) |
if not newNode.getAttribute("view"): newNode.setAttribute("view", "DefaultWidget") | def _iterateData(self, parentNode, submodel, data): """ """ currentListItem = 0 for key in data.keys(): if not newNode: newNode = self.getPattern('item') if newNode: warnings.warn("itemOf= is deprecated, " "please use listItemOf instead", DeprecationWarning) appendModel(newNode, key) | |
adapter = adaptable.getComponent(self, registry, _Nothing) | adapter = adaptable.getComponent(self, registry, default=_Nothing) | def __call__(self, adaptable, default=_Nothing, persist=None, registry=None): """ Try to adapt `adaptable' to self; return `default' if it was passed, otherwise raise L{CannotAdapt}. """ adapter = default registry = getRegistry(registry) try: # should this be `implements' of some kind? if (persist is None or persist) a... |
return self.original.getComponent(interface, registry=None, default=None) | return self.original.getComponent(interface, registry=None, default=default) | def getComponent(self, interface, registry=None, default=None): """ I forward getComponent to self.original on the assumption that it is an instance of Componentized. """ return self.original.getComponent(interface, registry=None, default=None) |
errback, as appropriate.""" | errback, as appropriate. It is merely a shorthand way of performing the following:: self.addCallbacks(d.callback, d.errback) When you chain a deferred d2 to another deferred d1 with d1.chainDeferred(d2), you are making d2 participate in the callback chain of d1. Thus any event that fires d1 will also fire d2. However... | def chainDeferred(self, d): """Chain another Deferred to this Deferred. |
class ISFTPFile: | class ISFTPFile(Interface): | def realPath(self, path): """ Convert any path to an absolute path. |
class ISFTPFile: """ This represents an open file on the server. An object adhering to this interface should be returned from openFile(). """ def close(self): """ Close the file. This method returns nothing if the close succeeds immediatly, or a Deferred that is called back when the close succeeds. """ def readChun... | def setAttrs(self, attrs): """ Set the attributes for the file. | |
_drdw = self._doWriteOrRead | def doKEvent(self, timeout, reads=reads, writes=writes, selectables=selectables, kq=kq, log=log, OSError=OSError, EVFILT_READ=EVFILT_READ, EVFILT_WRITE=EVFILT_WRITE): """Poll the kqueue for new events.""" if timeout is None: timeout = 1000 else: timeout = int(timeout * 1000) # convert seconds to milliseconds | |
log.logOwner.own(selectable) try: if filter == EVFILT_READ: why = selectable.doRead() if filter == EVFILT_WRITE: why = selectable.doWrite() if not selectable.fileno() == fd: why = main.CONNECTION_LOST except: why = sys.exc_value log.deferr() if why: self.removeReader(selectable) self.removeWriter(selectable) try: sel... | log.callWithLogger(selectable, _drdw, selectable, fd, filter) def _doWriteOrRead(self, selectable, fd, filter): try: if filter == EVFILT_READ: why = selectable.doRead() if filter == EVFILT_WRITE: why = selectable.doWrite() if not selectable.fileno() == fd: why = main.CONNECTION_LOST except: why = sys.exc_value log.def... | def doKEvent(self, timeout, reads=reads, writes=writes, selectables=selectables, kq=kq, log=log, OSError=OSError, EVFILT_READ=EVFILT_READ, EVFILT_WRITE=EVFILT_WRITE): """Poll the kqueue for new events.""" if timeout is None: timeout = 1000 else: timeout = int(timeout * 1000) # convert seconds to milliseconds |
print self.views | 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... | |
self.addr = port | def __init__(self, host, port, protocol): """Initialize the client, setting up its socket, and request to connect. """ if host == 'unix': # we are using unix sockets skt = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) # "port" in this case is really a filename self.addr = port else: skt = self.createInternetSocket(... | |
log.msg('error on port %s: %s' % (port.port, msg[1])) | log.msg('error on port %s: %s' % (port.port, msg)) | def run(self, save=1, installSignalHandlers=1): """Run this application, running the main loop if necessary. """ global resolver if not self.running: log.logOwner.own(self) for delayed in self.delayeds: main.addDelayed(delayed) if save: main.addShutdown(self.shutDownSave) for port in self.ports: try: port.startListenin... |
self.deferred.errback(failure.Failure(IOError("got stderr"))) self.deferred = None self.transport.loseConnection() | if self.deferred is not None: self.deferred.errback(failure.Failure(IOError("got stderr: %r" % text))) self.deferred = None self.transport.loseConnection() | def errReceivedIsBad(self, text): self.deferred.errback(failure.Failure(IOError("got stderr"))) self.deferred = None self.transport.loseConnection() |
self.win.remove(self.widget) self.currentlyVisible = 0 self.win.disconnect(self.connectid) self.win.destroy() | if self.currentlyVisible: self.win.remove(self.widget) self.currentlyVisible = 0 self.win.disconnect(self.connectid) self.win.destroy() | def hide(self): self.win.remove(self.widget) self.currentlyVisible = 0 self.win.disconnect(self.connectid) self.win.destroy() |
class _IReactorWaker(Interface): """I am a waker for the select reactor""" | def connectWith(self, connectorType, *args, **kw): kw['reactor'] = self c = connectorType(*args, **kw) c.connect() return c | |
implements(_IReactorWaker) | def connectWith(self, connectorType, *args, **kw): kw['reactor'] = self c = connectorType(*args, **kw) c.connect() return c | |
implements(_IReactorWaker) | def connectionLost(self, reason): self.r.close() self.w.close() self.reactor.waker = None | |
readers = reads.keys() | readers = [reader for reader in reads.iterkeys() if reader is not self.waker] | def removeAll(self): """Remove all readers and writers, and return list of Selectables.""" readers = reads.keys() for reader in readers: if reads.has_key(reader): del reads[reader] if writes.has_key(reader): del writes[reader] self.waker = None return readers |
self.waker = None | def removeAll(self): """Remove all readers and writers, and return list of Selectables.""" readers = reads.keys() for reader in readers: if reads.has_key(reader): del reads[reader] if writes.has_key(reader): del writes[reader] self.waker = None return readers | |
return [reader for reader in self.removeAll() if not _IReactorWaker.providedBy(reader)] | return self.removeAll() | def cleanup(self): """Remove all readers and writers, and return a list of Selectables that represent dirty reactor state """ return [reader for reader in self.removeAll() if not _IReactorWaker.providedBy(reader)] |
def __init__(self, stream=sys.stdout, tbformat='default', args=None, realtime=False): super(TextReporter, self).__init__(stream, tbformat, args, realtime) self.seenModules, self.seenClasses = {}, {} | def __init__(self, stream=sys.stdout, tbformat='default', args=None, realtime=False): super(TextReporter, self).__init__(stream, tbformat, args, realtime) self.seenModules, self.seenClasses = {}, {} | |
class VerboseTextReporter(TextReporter): | class VerboseTextReporter(Reporter): | def endTest(self, method): self.write(LETTERS.get(self.getStatus(method), '?')) super(TextReporter, self).endTest(method) |
class TimingTextReporter(VerboseTextReporter): | class TimingTextReporter(Reporter): def startTest(self, tm): self.write('%s ... ', tm.id()) super(VerboseTextReporter, self).startTest(tm) | def endTest(self, method): self.write("%s\n" % WORDS.get(self.getStatus(method), "[??]")) super(VerboseTextReporter, self).endTest(method) |
class TreeReporter(VerboseTextReporter): | class TreeReporter(Reporter): | def endTest(self, method): self.write("%s" % WORDS.get(self.getStatus(method), "[??]") + " " + "(%.03f secs)\n" % method.runningTime()) super(TimingTextReporter, self).endTest(method) |
super(VerboseTextReporter, self).startTest(method) | super(TreeReporter, self).startTest(method) | def startTest(self, method): self.write(' %s ... ', method.shortDescription()) super(VerboseTextReporter, self).startTest(method) |
Reporter.endTest(self, method) | def endTest(self, method): Reporter.endTest(self, method) self.endLine(*self._getText(self.getStatus(method))) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.