and automatically using distribute instead of setuptools. Well, I guess that things have changed and now distribute has been merged into setuptools and distribute is deprecated and setuptools is the thing to use. It may take me a little while to unlearn my old habits and it might make explaining Python packaging a little bit more difficult (not that it was easy :-)).
Finally fixed one little thing that was annoying me on my work laptop with OS X 10.8.4. I couldn’t double-tap to drag files or make selections.
The fix is dead simple and it’s from this CNET article:
If you want to reactivate the classic double-tap-and-drag gesture, it’s possible, but the option is well-hidden. Instead of being in System Preferences under Trackpad, it’s actually under System Preferences > Universal Access > Mouse and Trackpad > Trackpad Options. Click the check box that says “Dragging” and you should be all set.
In Mountain Lion, it seems that “Universal Access” was renamed to “Accessibility”.
I have sometimes had a git branch called “tests” because I was adding tests or working on tests. The problem is that many projects have a “tests” directory so if you have a “test” branch, you get this:
$ git diff tests fatal: ambiguous argument 'tests': both revision and filename Use '--' to separate paths from revisions, like this: 'git
[ ...] -- [ ...]'
You can of course use
git diff -- tests and it will work, but it’s easier to just not name a branch “tests” in the first place.
Doing my yearly ritual of looking at Plone & Zope and making sure I still don’t grok them. Check.
In this year’s installment, I set up a little Plone site and actually got as far as creating a custom content type. I started down the road of thinking I would create the content type manually with code in Archetypes. Then I looked at tutorials and saw that it looked like it involved a lot of repetitive code and configuration voodoo. I ended up using ZopeSkel to create a really, really simple Archetypes content type, which actually didn’t take too long to figure out (to my pleasant surprise).
It still feels like too much work and it’s difficult to find good documentation on what’s the current recommended way to do things, because the recommended way of doing things seems to change every couple of years and there is a lot of old, outdated documentation out there. A search on Archetypes for instance yielded all kinds of pages referring to practices that seem to be outdated now, like manually creating the directory structure for an Archetypes product (i.e.: no ZopeSkel) and copying the product into the Zope 2 “Products” directory (which seems to be deprecated in favor of
In comparison, creating a model in Django is very simple, Pythonic, and well-documented.
My previous setup worked until I wanted to add another Django instance and then it didn’t work, because I had two
WSGIScriptAlias entries under different URLs but it would launch whichever app it wanted to regardless of the URL. A little searching suggested that it had to do with mod_wsgi process pools. I eventually ended up with something like this:
WSGIPythonHome /www/python/pypi.venv WSGIPythonPath /www/python/django WSGIPassAuthorization On WSGISocketPrefix /var/run/wsgi <VirtualHost *:80> ... DocumentRoot /www/python WSGIDaemonProcess djangoplayground_wsgi user=apache python-path=/www/python/django WSGIScriptAlias /djangoplayground /www/python/django/djangoplayground/wsgi.py <Location /djangoplayground> WSGIProcessGroup djangoplayground_wsgi </Location> WSGIDaemonProcess djangopypi_wsgi user=apache python-path=/www/python/django WSGIScriptAlias /djangopypi /www/python/django/djangopypisite/wsgi.py <Location /djangopypi> WSGIProcessGroup djangopypi_wsgi </Location> </VirtualHost>
I had been working on DjangoPyPI and trying to fix some tests related to XML-RPC that were failing in versions of Python < 2.7, because the testing was relying on specifics of the implementation of
xmlrpclib in Python 2.7. I found some code at this blog post from Forest Bond that showed a better way to test XML-RPC views in Django, namely, by creating a special XML-RPC transport object that uses the Django test client. I extracted this out and tweaked it slightly to add tests and better compatibility across Python versions and published it on PyPI as…
Test Django XML-RPC views using the Django test client. Because you’re using the Django test client, you’re not actually sending HTTP requests and don’t need a server running.
from djangotestxmlrpc import DjangoTestClientXMLRPCTransport class TestXmlRpc(django.test.TestCase): ... def test_list_package(self): pypi = xmlrpclib.ServerProxy( "http://localhost/pypi/", transport=DjangoTestClientXMLRPCTransport(self.client)) pypi_hits = pypi.list_packages() expected = ['foo'] self.assertEqual(pypi_hits, expected)
Supported Python versions
- Python 2.5
- Python 2.6
- Python 2.7
- PyPy 1.9
- Python 3.1
- Python 3.2
or says tox:
~/dev/git-repos/djangotestxmlrpc$ tox ... py25: commands succeeded py26: commands succeeded py27: commands succeeded pypy: commands succeeded py31: commands succeeded py32: commands succeeded congratulations :)
You also can check the latest Travis CI results, but Travis doesn’t build all of the above platforms.
Send your bug reports and feature requests to https://github.com/msabramo/djangotestxmlrpc/issues
I recently set up an internal PyPI server at work for hosting some of our internal Python packages. I used djangopypi and that was pretty easy to set up and get it working in the Django runserver. Most of the difficulty came in getting it to run in Apache with mod_wsgi. I always find mod_wsgi a little difficult to set up, so I thought I’d jot down a few notes on things I ran into and how I solved them, for future readers (including my future self! :-))
Prerequisite: Which Python are you going to use?
I’m going to briefly cover this, because getting Python installed on your OS of choice could be a blog post in itself. Are you going to use the system Python? This is easiest if your OS has a recent enough version that you want to use. Mine, CentOS 5.5, in this case comes with Python 2.4.3, which is pretty long in the tooth, so I wouldn’t bother with it. Even if it was a modern Python, I tend to shy away from doing much with the system Python, because it’s the system python, and I don’t want to do things and break my system. You might be OK with using a virtualenv of your system Python to get some isolation or you might do like I did in this case and simply install a fresh new version of Python with no connection whatsoever to the system Python. In fact, I installed a new Python and created a virtualenv in it specifically for the Django stuff I was doing.
Depending on your OS and package repositories, it might be an
apt-get install or
yum install away. For me it wasn’t and I downloaded and built it from source. Make sure that mod_wsgi is compiled against the Python version that you actually want to use. It’s pretty easy for it to link against your system Python or some other Python you don’t intend to use and that will cause problems. I built mine like this:
PATH=/usr/local/bin:/usr/bin:/bin ./configure --with-python=/usr/local/bin/python LD_RUN_PATH=/usr/local/lib make sudo make install
I needed the
LD_RUN_PATH stuff so that
mod_wsgi.so could link with
/usr/local/lib/libpython2.7.so.1.0 at runtime. This installed
/usr/lib64/httpd/modules/mod_wsgi.so (which is also available at
/etc/httpd/modules/mod_wsgi.so because I already had a symlink from
Turn on mod_wsgi in the Apache config
For me, I had to do:
$ cat /etc/httpd/conf.d/wsgi.conf LoadModule wsgi_module modules/mod_wsgi.so
Important: Turn off mod_python!
This is sort of commonly-known wisdom for people who are in the know about mod_wsgi, but I don’t set up mod_wsgi very often and so I forgot about it. And it caused great pain, because it caused a very mysterious failure. Basically, I had a state where a “Hello World” WSGI app worked just fine, but when I tried to use the
wsgi.py of my Django site, it would crap out silently. No errors in the Apache error log even with
LogLevel set to
debug. Through some ugly hacking of the
wsgi.py and some files in Django itself, I could see that it was silently dying inside Django when it got to the statement:
from threading import Lock
I did a bunch of searching and found posts of people having similar troubles but I didn’t find an answer.
And then I remembered to try turning off mod_python and that worked! Which was good, but it burned a lot of my time and psychic energy. All I had to do was comment out the following line in
# LoadModule python_module modules/mod_python.so
I wonder if mod_wsgi could be modified to detect the presence of mod_python and if it finds it, blast the logs with warnings? Frankly, I don’t know enough about Apache modules to know if this is possible.
Set up an Apache config that points to the wsgi.py
Mine looks roughly like this:
WSGIPythonHome /www/python/pypi.venv WSGIPythonPath /www/python/django WSGIPassAuthorization On <VirtualHost *:80> ... DocumentRoot /www/python WSGIScriptAlias /djangopypi /www/python/django/djangopypisite/wsgi.py ... </VirtualHost>
This of course will have to be heavily customized depending on whether you’re using a virtualenv and where it is and where your app is located, etc.
WSGIPassAuthorization On line is something that I didn’t have at first and only later ran into problems and ended up adding it…
Test it out…
At this point, I had the Django app working more or less the same as it was working in the Django runserver except…
Make sure directories are writable by Apache, etc.
If you set up everything initially as your own user and then moved it over to mod_wsgi, then you might have files that belong to your user and which are not writable by Apache. Log directories, SQLite databases, directories for uploaded files (typically called “media” in Django paralance), etc.
Setting up static serving
The Django runserver makes things easy by serving static files for you. Django when deployed via mod_wsgi won’t serve static files by default. There are probably hacks to make it do that, but if you’re already running Apache it makes more sense to just have Apache serve those static files. That is certainly what the Django guys encourage. I set the
MEDIA_URL settings in
settings.py and then did some symlinking and Apache configuration so that Apache could serve the files out of
/www/python/media. And I created a directory
/www/python/static for stuff like CSS and JS files and collected them from the apps into this directory using
python manage.py collectstatic.
WSGIPassAuthorization On: The last piece of the puzzle
At this point, I had done a lot of hacking and got it mostly working. The one missing piece was that I could not upload packages to my custom PyPI server (i.e.: with
python setup.py register -r chegg sdist upload -r chegg). Actually it worked when I had my
~/.pypirc pointed to the Django runserver; it just didn’t work with the mod_wsgi version — it failed with
Upload failed (401): UNAUTHORIZED. This took a while to figure out, but I eventually found the reason and answer here. Basically this is because djangopypi does checking of the HTTP
Authorization header in order to see if you’re authorized, and mod_wsgi by default filters out this header as a security precaution, on the assumption that you would let Apache do the authorization check and not involve the WSGI apps in this. I imagine that this is something useful for providers of shared web hosting, but it obviously will not work if you have WSGI apps doing their own authorization, as I had in this case with djangopypi. The answer was to turn on
WSGIPassAuthorization by adding
WSGIPassAuthorization On to my Apache vhost config.
That’s all folks!
So now it’s working although it took annoyingly long to set up.
The temptation was to move on as quickly as possible to something else now since I spent more time than I wanted to on this. Surely I’m now a smarter, wiser person who learned and won’t run into these problems next time… On second thought, realistically I may not have to do this again for months…or years…and I know myself well enough to know that I probably won’t remember much of this in a year. So I decided to invest just a little more time in writing down some of the high-level points so that I (or someone else) can refer to them later. And now because I blogged it, a few months from now, I will only have to remember to search my blog to find this post…