Introduction¶
Crochet: Use Twisted anywhere!¶
Crochet is an MIT-licensed library that makes it easier to use Twisted from regular blocking code. Some use cases include:
- Easily use Twisted from a blocking framework like Django or Flask.
- Write a library that provides a blocking API, but uses Twisted for its implementation.
- Port blocking code to Twisted more easily, by keeping a backwards compatibility layer.
- Allow normal Twisted programs that use threads to interact with Twisted more cleanly from their threaded parts. For example, this can be useful when using Twisted as a WSGI container.
Crochet is maintained by Itamar Turner-Trauring.
You can install Crochet by running:
$ pip install crochet
Downloads are available on PyPI.
Documentation can be found on Read The Docs.
Bugs and feature requests should be filed at the project Github page.
API and features¶
![Build Status](https://travis-ci.org/itamarst/crochet.png?branch=master)
Crochet supports Python 2.7, 3.4, 3.5 and 3.6 as well as PyPy.
Crochet provides the following basic APIs:
- Allow blocking code to call into Twisted and block until results are available
or a timeout is hit, using the
crochet.wait_for
decorator. - A lower-level API (
crochet.run_in_reactor
) allows blocking code to run code “in the background” in the Twisted thread, with the ability to repeatedly check if it’s done.
Crochet will do the following on your behalf in order to enable these APIs:
- Transparently start Twisted’s reactor in a thread it manages.
- Shut down the reactor automatically when the process’ main thread finishes.
- Hook up Twisted’s log system to the Python standard library
logging
framework. Unlike Twisted’s built-inlogging
bridge, this includes support for blocking Handler instances.
Examples¶
Background scheduling¶
You can use Crochet to schedule events that will run in the background without slowing down the page rendering of your web applications:
#!/usr/bin/python
"""
An example of scheduling time-based events in the background.
Download the latest EUR/USD exchange rate from Yahoo every 30 seconds in the
background; the rendered Flask web page can use the latest value without
having to do the request itself.
Note this is example is for demonstration purposes only, and is not actually
used in the real world. You should not do this in a real application without
reading Yahoo's terms-of-service and following them.
"""
from __future__ import print_function
from flask import Flask
from twisted.internet.task import LoopingCall
from twisted.web.client import getPage
from twisted.python import log
from crochet import wait_for, run_in_reactor, setup
setup()
# Twisted code:
class _ExchangeRate(object):
"""Download an exchange rate from Yahoo Finance using Twisted."""
def __init__(self, name):
self._value = None
self._name = name
# External API:
def latest_value(self):
"""Return the latest exchange rate value.
May be None if no value is available.
"""
return self._value
def start(self):
"""Start the background process."""
self._lc = LoopingCall(self._download)
# Run immediately, and then every 30 seconds:
self._lc.start(30, now=True)
def _download(self):
"""Download the page."""
print("Downloading!")
def parse(result):
print("Got %r back from Yahoo." % (result,))
values = result.strip().split(",")
self._value = float(values[1])
d = getPage(
"http://download.finance.yahoo.com/d/quotes.csv?e=.csv&f=c4l1&s=%s=X"
% (self._name,))
d.addCallback(parse)
d.addErrback(log.err)
return d
# Blocking wrapper:
class ExchangeRate(object):
"""Blocking API for downloading exchange rate."""
def __init__(self, name):
self._exchange = _ExchangeRate(name)
@run_in_reactor
def start(self):
self._exchange.start()
@wait_for(timeout=1)
def latest_value(self):
"""Return the latest exchange rate value.
May be None if no value is available.
"""
return self._exchange.latest_value()
EURUSD = ExchangeRate("EURUSD")
app = Flask(__name__)
@app.route('/')
def index():
rate = EURUSD.latest_value()
if rate is None:
rate = "unavailable, please refresh the page"
return "Current EUR/USD exchange rate is %s." % (rate,)
if __name__ == '__main__':
import sys, logging
logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
EURUSD.start()
app.run()
SSH into your server¶
You can SSH into your Python process and get a Python prompt, allowing you to poke around in the internals of your running program:
#!/usr/bin/python
"""
A demonstration of Conch, allowing you to SSH into a running Python server and
inspect objects at a Python prompt.
If you're using the system install of Twisted, you may need to install Conch
separately, e.g. on Ubuntu:
$ sudo apt-get install python-twisted-conch
Once you've started the program, you can ssh in by doing:
$ ssh admin@localhost -p 5022
The password is 'secret'. Once you've reached the Python prompt, you have
access to the app object, and can import code, etc.:
>>> 3 + 4
7
>>> print(app)
<flask.app.Flask object at 0x18e1690>
"""
import logging
from flask import Flask
from crochet import setup, run_in_reactor
setup()
# Web server:
app = Flask(__name__)
@app.route('/')
def index():
return "Welcome to my boring web server!"
@run_in_reactor
def start_ssh_server(port, username, password, namespace):
"""
Start an SSH server on the given port, exposing a Python prompt with the
given namespace.
"""
# This is a lot of boilerplate, see http://tm.tl/6429 for a ticket to
# provide a utility function that simplifies this.
from twisted.internet import reactor
from twisted.conch.insults import insults
from twisted.conch import manhole, manhole_ssh
from twisted.cred.checkers import (
InMemoryUsernamePasswordDatabaseDontUse as MemoryDB)
from twisted.cred.portal import Portal
sshRealm = manhole_ssh.TerminalRealm()
def chainedProtocolFactory():
return insults.ServerProtocol(manhole.Manhole, namespace)
sshRealm.chainedProtocolFactory = chainedProtocolFactory
sshPortal = Portal(sshRealm, [MemoryDB(**{username: password})])
reactor.listenTCP(port, manhole_ssh.ConchFactory(sshPortal),
interface="127.0.0.1")
if __name__ == '__main__':
import sys
logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
start_ssh_server(5022, "admin", "secret", {"app": app})
app.run()
DNS query¶
Twisted also has a fully featured DNS library:
#!/usr/bin/python
"""
A command-line application that uses Twisted to do an MX DNS query.
"""
from __future__ import print_function
from twisted.names.client import lookupMailExchange
from crochet import setup, wait_for
setup()
# Twisted code:
def _mx(domain):
"""
Return Deferred that fires with a list of (priority, MX domain) tuples for
a given domain.
"""
def got_records(result):
return sorted(
[(int(record.payload.preference), str(record.payload.name))
for record in result[0]])
d = lookupMailExchange(domain)
d.addCallback(got_records)
return d
# Blocking wrapper:
@wait_for(timeout=5)
def mx(domain):
"""
Return list of (priority, MX domain) tuples for a given domain.
"""
return _mx(domain)
# Application code:
def main(domain):
print("Mail servers for %s:" % (domain,))
for priority, mailserver in mx(domain):
print(priority, mailserver)
if __name__ == '__main__':
import sys
main(sys.argv[1])
Using Crochet in normal Twisted code¶
You can use Crochet’s APIs for calling into the reactor thread from normal Twisted applications:
#!/usr/bin/python
"""
An example of using Crochet from a normal Twisted application.
"""
import sys
from crochet import no_setup, wait_for
# Tell Crochet not to run the reactor:
no_setup()
from twisted.internet import reactor
from twisted.python import log
from twisted.web.wsgi import WSGIResource
from twisted.web.server import Site
from twisted.names import client
# A WSGI application, will be run in thread pool:
def application(environ, start_response):
start_response('200 OK', [])
try:
ip = gethostbyname('twistedmatrix.com')
return "%s has IP %s" % ('twistedmatrix.com', ip)
except Exception, e:
return 'Error doing lookup: %s' % (e,)
# A blocking API that will be called from the WSGI application, but actually
# uses DNS:
@wait_for(timeout=10)
def gethostbyname(name):
d = client.lookupAddress(name)
d.addCallback(lambda result: result[0][0].payload.dottedQuad())
return d
# Normal Twisted code, serving the WSGI application and running the reactor:
def main():
log.startLogging(sys.stdout)
pool = reactor.getThreadPool()
reactor.listenTCP(5000, Site(WSGIResource(reactor, pool, application)))
reactor.run()
if __name__ == '__main__':
main()