Here are the examples of the python api twisted.internet.abstract.FileDescriptor.__init__ taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
11 Examples
3
Example 1
def __init__(self, conn, onRead, *args, **kwargs):
abstract.FileDescriptor.__init__(self, *args, **kwargs)
self.conn = conn
self.onRead = onRead
self.reading = False
self.writing = False
3
Example 2
def __init__(self, reactor, proc, name, fileno):
"""
Initialize, specifying a process to connect to.
"""
abstract.FileDescriptor.__init__(self, reactor)
fdesc.setNonBlocking(fileno)
self.proc = proc
self.name = name
self.fd = fileno
self.startReading()
3
Example 3
def __init__(self, skt, protocol, reactor=None):
abstract.FileDescriptor.__init__(self, reactor=reactor)
self.socket = skt
self.socket.setblocking(0)
self.fileno = skt.fileno
self.protocol = protocol
3
Example 4
def __init__(self, protocol, deviceNameOrPortNumber, reactor,
baudrate = 9600, bytesize = EIGHTBITS, parity = PARITY_NONE,
stopbits = STOPBITS_ONE, timeout = 0, xonxoff = 0, rtscts = 0):
abstract.FileDescriptor.__init__(self, reactor)
self._serial = serial.Serial(deviceNameOrPortNumber, baudrate = baudrate, bytesize = bytesize, parity = parity, stopbits = stopbits, timeout = timeout, xonxoff = xonxoff, rtscts = rtscts)
self.reactor = reactor
self.flushInput()
self.flushOutput()
self.protocol = protocol
self.protocol.makeConnection(self)
self.startReading()
3
Example 5
def __init__(self, fp, callback):
self.fp = fp
fdesc.setNonBlocking(fp)
self.callback = callback
self.fileno = self.fp.fileno
abstract.FileDescriptor.__init__(self, reactor)
3
Example 6
def __init__(self, protocol, deviceNameOrPortNumber, reactor,
baudrate = 9600, bytesize = EIGHTBITS, parity = PARITY_NONE,
stopbits = STOPBITS_ONE, timeout = 0, xonxoff = 0, rtscts = 0):
abstract.FileDescriptor.__init__(self, reactor)
self._serial = self._serialFactory(
deviceNameOrPortNumber, baudrate=baudrate, bytesize=bytesize,
parity=parity, stopbits=stopbits, timeout=timeout,
xonxoff=xonxoff, rtscts=rtscts)
self.reactor = reactor
self.flushInput()
self.flushOutput()
self.protocol = protocol
self.protocol.makeConnection(self)
self.startReading()
0
Example 7
def __init__(self, reactor, fd, cb):
self._fileno = fd
self.cb = cb
FileDescriptor.__init__(self, reactor)
0
Example 8
Project: mythbox Source File: inotify.py
def __init__(self, reactor=None):
FileDescriptor.__init__(self, reactor=reactor)
# Smart way to allow parametrization of libc so I can override
# it and test for the system errors.
self._fd = self._inotify.init()
fdesc.setNonBlocking(self._fd)
fdesc._setCloseOnExec(self._fd)
# The next 2 lines are needed to have self.loseConnection()
# to call connectionLost() on us. Since we already created the
# fd that talks to inotify we want to be notified even if we
# haven't yet started reading.
self.connected = 1
self._writeDisconnected = True
self._buffer = ''
self._watchpoints = {}
self._watchpaths = {}
0
Example 9
Project: mythbox Source File: process.py
def __init__(self, reactor, proc, name, fileno, forceReadHack=False):
"""
Initialize, specifying a Process instance to connect to.
"""
abstract.FileDescriptor.__init__(self, reactor)
fdesc.setNonBlocking(fileno)
self.proc = proc
self.name = name
self.fd = fileno
if not stat.S_ISFIFO(os.fstat(self.fileno()).st_mode):
# If the fd is not a pipe, then the read hack is never
# applicable. This case arises when ProcessWriter is used by
# StandardIO and stdout is redirected to a normal file.
self.enableReadHack = False
elif forceReadHack:
self.enableReadHack = True
else:
# Detect if this fd is actually a write-only fd. If it's
# valid to read, don't try to detect closing via read.
# This really only means that we cannot detect a TTY's write
# pipe being closed.
try:
os.read(self.fileno(), 0)
except OSError:
# It's a write-only pipe end, enable hack
self.enableReadHack = True
if self.enableReadHack:
self.startReading()
0
Example 10
Project: mythbox Source File: process.py
def __init__(self, reactor, executable, args, environment, path, proto,
uid=None, gid=None, usePTY=None):
"""
Spawn an operating-system process.
This is where the hard work of disconnecting all currently open
files / forking / executing the new process happens. (This is
executed automatically when a Process is instantiated.)
This will also run the subprocess as a given user ID and group ID, if
specified. (Implementation Note: this doesn't support all the arcane
nuances of setXXuid on UNIX: it will assume that either your effective
or real UID is 0.)
"""
if pty is None and not isinstance(usePTY, (tuple, list)):
# no pty module and we didn't get a pty to use
raise NotImplementedError(
"cannot use PTYProcess on platforms without the pty module.")
abstract.FileDescriptor.__init__(self, reactor)
_BaseProcess.__init__(self, proto)
if isinstance(usePTY, (tuple, list)):
masterfd, slavefd, ttyname = usePTY
else:
masterfd, slavefd = pty.openpty()
ttyname = os.ttyname(slavefd)
try:
self._fork(path, uid, gid, executable, args, environment,
masterfd=masterfd, slavefd=slavefd)
except:
if not isinstance(usePTY, (tuple, list)):
os.close(masterfd)
os.close(slavefd)
raise
# we are now in parent process:
os.close(slavefd)
fdesc.setNonBlocking(masterfd)
self.fd = masterfd
self.startReading()
self.connected = 1
self.status = -1
try:
self.proto.makeConnection(self)
except:
log.err()
registerReapProcessHandler(self.pid, self)
0
Example 11
Project: ccx2 Source File: main_loop.py
def twisted_main_loop(topmost_widget, palette=[], screen=None,
handle_mouse=True, input_filter=None, unhandled_input=None,
handle_reactor=True):
"""
A version of generic_main_loop that uses the twisted library.
Most parameters are the same as generic_main_loop.
handle_reactor - if False, rather than looping the function simply
returns a twisted Deferred that will trigger when
the UI shuts down
"""
from twisted.internet import reactor
from twisted.internet.defer import Deferred
from twisted.python.failure import Failure
from twisted.internet.abstract import FileDescriptor
class InputDescriptor(FileDescriptor):
def __init__(self, fd, cb):
self._fileno = fd
self.cb = cb
FileDescriptor.__init__(self, reactor)
def fileno(self):
return self._fileno
def doRead(self):
return self.cb()
class TwistedLoopManager(object):
def __init__(self, screen, topmost_widget, input_filter, unhandled_input,
need_stop, handle_reactor):
self.screen = screen
self.topmost_widget = topmost_widget
self.failure = None
self.handle_reactor = handle_reactor
if input_filter:
self.input_filter = input_filter
if unhandled_input:
self.unhandled_input = unhandled_input
self.need_stop = need_stop
def input_filter(self, k):
return k
def unhandled_input(self, k):
pass
def stop(self, failure=None):
if self.need_stop:
self.screen.stop()
self.need_stop = False
self.running = False
if failure:
self.d.errback(failure)
else:
self.d.callback(True)
if self.handle_reactor:
reactor.stop()
self.handle_reactor = False
elif self.triggerid:
self.removeSystemEventTrigger(self.triggerid)
self.triggerid = None
def refresh(self):
if not self.running:
return
try:
canvas = self.topmost_widget.render(self.size, focus=True)
self.screen.draw_screen(self.size, canvas)
except ExitMainLoop:
self.stop()
except:
self.stop(Failure())
def onShutdown(self):
if self.need_stop:
self.screen.stop()
self.need_stop = False
if self.running:
self.stop()
def inputCallback(self):
if self.running:
timeout, events, raw = self.screen.get_input_nonblocking()
if events:
for event in events:
self.onInput(event)
self.refresh()
def run(self):
self.d = Deferred()
self.running = True
self.triggerid = reactor.addSystemEventTrigger('before', 'shutdown', self.onShutdown)
self.size = self.screen.get_cols_rows()
self.refresh()
for desc in self.screen.get_input_descriptors():
id = InputDescriptor(desc, self.inputCallback)
reactor.addReader(id)
return self.d
def onInput(self, event):
if not self.running:
return
try:
if event == 'window resize':
self.size = self.screen.get_cols_rows()
event = self.input_filter(event)
if is_mouse_event(event):
if self.topmost_widget.mouse_event(self.size, focus=True, *event):
event = None
else:
event = self.topmost_widget.keypress(self.size, event)
if event:
self.unhandled_input(event)
except ExitMainLoop:
self.stop()
except:
self.stop(Failure())
if not screen:
import raw_display
screen = raw_display.Screen()
if palette:
screen.register_palette(palette)
needstop = False
handleStartStop = not screen.started
if handleStartStop:
screen.start()
needstop = True
mgr = TwistedLoopManager(screen, topmost_widget, input_filter,
unhandled_input, needstop, handle_reactor)
if handle_mouse:
screen.set_mouse_tracking()
d = mgr.run()
if handle_reactor:
d.addErrback(lambda fail: fail.printTraceback())
reactor.run()
else:
return d