Twisted Asynchronous Networking Framework

25.5.0 · active · verified Thu Apr 09

Twisted is a powerful, event-driven networking framework for Python, enabling asynchronous programming with a strong emphasis on protocols and concurrency. It provides abstractions for common network programming tasks, including TCP/UDP, HTTP, DNS, and more. It is actively maintained with frequent releases, typically every 1-3 months. The current stable version is 25.5.0.

Warnings

breaking The methods `deferSetUp`, `deferTestMethod`, `deferTearDown`, and `deferRunCleanups` on `twisted.trial.unittest.TestCase` have been removed.
Fix: Migrate away from these deprecated methods. Twisted's `trial` testing framework encourages standard async/await or direct Deferred usage for setup/teardown.
gotcha Any blocking call (e.g., `time.sleep()`, synchronous I/O, long-running computations) will halt the entire Twisted reactor and block all other active connections and operations.
Fix: Always use Twisted's asynchronous primitives (e.g., `reactor.callLater`, `defer.Deferred`, `inlineCallbacks`, `twisted.internet.threads.deferToThread`) for operations that might block. Offload CPU-bound tasks to separate threads or processes.
gotcha The `twisted.python.failure.Failure` object, which encapsulates tracebacks for error handling, no longer records the exact point of its creation for performance reasons.
Fix: If you relied on the exact creation traceback for debugging, be aware this information is no longer available. Focus on the traceback within the `Failure` object itself, which points to where the error occurred, rather than where the `Failure` object was instantiated.
gotcha Understanding and correctly chaining `defer.Deferred` objects, especially handling errors (errbacks), can be complex. Unhandled errors in a Deferred chain can silently disappear or lead to unexpected behavior.
Fix: Always attach an errback to the end of a Deferred chain to catch and log unhandled errors, or ensure that all possible error paths are explicitly handled. Use `inlineCallbacks` or Python's `async/await` syntax (when yielding coroutines, supported from 24.7.0) to simplify Deferred management.

Install

pip install twisted Install latest stable version

Imports

reactor
```
from twisted.internet import reactor
```
The core event loop object.
protocol
```
from twisted.internet import protocol
```
Base classes for implementing network protocols.
defer
```
from twisted.internet import defer
```
Module for Deferred objects and inlineCallbacks.
server
```
from twisted.web import server, resource
```
Common imports for building web applications.

Quickstart

This quickstart demonstrates a simple echo server using Twisted's core `reactor` and `protocol` abstractions. It listens on port 8000 and sends back any data received.

from twisted.internet import reactor, protocol

class Echo(protocol.Protocol):
    """As soon as any data is received, send it back."""
    def dataReceived(self, data):
        self.transport.write(data)

class EchoFactory(protocol.Factory):
    def buildProtocol(self, addr):
        return Echo()

if __name__ == '__main__':
    # This will run the protocol on port 8000
    reactor.listenTCP(8000, EchoFactory())
    print("Echo server started on port 8000. Press Ctrl+C to stop.")
    reactor.run()

view raw JSON →