Tutorial: Adding Facebook/Twitter/Google Authentication to a Django Application

Leave a reply.
Image via http://www.djangopony.com/

Image via http://www.djangopony.com/

I needed to add Facebook authentication to a Django app today, and instead of writing it directly against the Facebook API (or re-implementing the OAuth2 dance again), I decided to look around and see if there’s a pre-packaged solution for this common task. Turns out, there’s an excellent project called Python Social Auth, and it covers pretty much any social website with an authentication API.

As it often happens with amazing open-source projects, the documentation is somewhat minimalistic. One key piece that I could not find was a tutorial. This post is aiming to fill that gap. In this tutorial, we will use Facebook, Twitter and Google, as the most common social APIs, but we could easily substitute them with LinkedIn, Yahoo, Forsquare, or a bunch of other providers supported by Python Social Auth library. Continue reading

SXSW Wrap-up

Leave a reply.

Now that I’ve been home for a month, I’m ready to write up my thoughts on my first time attending the South by Southwest Interactive festival in Austin, TX.

20140414-103312.jpg

A view from the green room

Art & Logic has had a presence at SXSW before (conveniently, we have a few account managers who live in Austin, so it was easy), but this was the first time that we’ve attended it aggressively. We had a booth on the trade show floor, and took part in a panel discussion on the topic of estimating software projects — Continue reading

JavaScript Isolation with Nodeenv

1 Reply.

I do a lot of Python work, and I’m a huge fan of virtualenv, which allows you to set up a completely isolated Python environment. This is hugely helpful to keep various dependencies from multiple projects from clobbering one another. It’s so helpful, that when I work in pretty much any other language, I miss having the ability to isolate things so nicely.

Since a lot of the Python work I do is also Web work, I frequently end up doing a lot of Javascript as well. The (relatively) recent appearance of node.js and various development tools based on it has been a great boon, but whenever I’ve had multiple projects using different versions of the same tool, I’ve craved a way to keep my Javascript environments as nicely separated as my Python environments. If only there was something like virtualenv, but for node.js…

In fact there are several ways such things, but my favorite by far is a project called nodeenv. It’s written in Python, which might seem a bit strange until you realize that it’s written specifically to integrate nicely with virtualenv.

Here’s how you use it. Or at least how I use it.

First create a virtualenv. Here I’m using virtualenvwrapper, but of course you can use vanilla virtualenv if you prefer:

$ mkproject nodeenv-test
New python executable in nodeenv-test/bin/python
Installing setuptools............done.
Installing pip...............done.
Creating /home/funsize/code/nodeenv-test
Setting project for nodeenv-test to /home/funsize/code/nodeenv-test

This will create a project directory, create a virtualenv, install pip into the virtualenv, activate it, and switch my current working directory to the project directory just created.

Now we install nodeenv into the virtualenv:

$ pip install nodeenv

This installs a command called, unsurprisingly, “nodeenv”, which we now run with the -p flag, which tells it to integrate with the current python virtualenv:

$ nodenv -p
 * Install node.js (0.10.26) ... done.
 * Appending nodeenv settings to /home/funsize/.virtualenvs/nodeenv-test/bin/activate

Everything will probably work fine at this point, but just to be safe, I like to reset the virtualenv by deactivating and reactivating it:

$ deactivate
$ workon nodeenv-test

(Again, I’m using virtualenvwrapper, which may or may not be to your taste).

At this point we are working in an isolated environment for both Python and Node.js. I can install libraries for Python using pip, or for Node using npm -g and they will not interact with my system Python libraries or Node libraries in any way. Some of you may recall that I’m a big fan of bower, so I can install it like so:

$ npm install -g bower

Bower has a bunch of dependencies, which npm takes care of for us, and all of those get installed into our isolated environment. They can’t interfere with any of our other projects in any way. Bliss!

Ok, so it’s not quite all sunshine and roses. nodeenv needs a bunch of dependencies to work, though nothing too outlandish (stuff like a C compiler, curl, etc.). This isn’t too onerous, and anyone who can install software packages on their machine should be able to get it working on pretty much any Unix flavor without too much trouble. I have not, much to my disappointment, been able to get it to work on Windows as of yet, even with all of the relevant dependencies installed. It appears to have something to do with the way Windows handles command parsing and/or escaping. If anyone out there has gotten it running on Windows, please let me know in the comments. With those caveats, though, nodeenv really is pretty fantastic.

Now this is the kind of thing that you may not really appreciate until you use it, so I encourage all of you out there to give this a shot. It really is worth your time. Enjoy!

Two Things I Missed Functional Testing with WebTest

Leave a reply.

Ian Bicking’s WebTest is a helpful module for running functional tests against a WSGI app. You may already be using it, it’s the suggested way to test Pyramid apps, TurboGears and Google App Engine, and (although I have no experience with this) you can use it with Django (apparently this is a good idea) and Flask. It’s not very complicated but in my haste to get things done I overlooked a couple of its nicest features.
python-logo-master-v3-TM
Continue reading

Accelerated, Lower Frustration Web Development with BrowserSync

Leave a reply.

With apologies to Mr. Poe:

I was fuming in frustration, sitting clicking at my station,
I'll spare you some narration, but I was getting pretty sore.
"Surely there must be some method, whereby changes are detected,
And perhaps then be injected into my page's DOM!", I swore.
"Some way to edit CSS without it being such a chore,
And click Refresh nevermore."

So I then took up the challenge, and began a quest for knowledge
on this strange mysterious thing for which I'd searched some times before.
But amidst auto-refresh plugins, and bookmarklets by the dozen,
Nothing did I find which would my page's state restore.
Then I chanced upon a newsfeed and this here did it implore:
"BrowserSync, you will adore."

-- not quite Edgar Allen Poe

BrowserSync is a nifty development tool for editing and/or testing websites. It’s written in JavaScript, on top of node.js, so you install it using npm (perhaps inside a nodeenv ). After installing it, you start it up something like this: Continue reading

Radically Cross Platform: Scripting with Kablooie

Leave a reply.
This Dog is Turing Complete.

This Dog is Turing Complete. (believekevin on Flickr)

How would you design your own ideal scripting language?  Would you go with a functional language in the LISP family, or with a more procedural style?  Would you offer object oriented organization?  Would large parts of your ideal language be recognizable as C or another common language, or would you “go for broke” with a domain specific language that (probably) only you will be able to read?

One of the fun things about computer science is that people will answer this question in very different ways, and they can all be right.  Almost everything (including your dog) is probably Turing complete.  And since the ultimate goal is accomplishing whatever operations the script is performing, whatever helps you express that well is the right answer, for you.

When implementing my cross platform graphical app engine, a set of characteristics began to crystalize for my ideal scripting language: Continue reading

Trying OpenStack with DevStack

Leave a reply.

4608617962_92d50edbfb_b

Photo by Andy Renny

Many of my recent projects have been single-server web applications using TurboGears or Flask that consume a few other services. While I was thinking about challenges like scaling, it occurred to me that I should take a look at OpenStack. I hope this will give me a better idea of how the cloud (which I take for granted) works.

You can read the history of OpenStack if you’re so inclined.  Here is what matters: it is a set of cooperating services that can be used to build and scale applications.  It is an open source counterpart to some of Amazon’s AWS offerings and it powers the cloud services offered by Rackspace, HP, Red Hat and others.

Continue reading

Follow Art & Logic on Twitter

Follow Our Blog via RSS

RSS

Connect Socially

A&L on Facebook

A&L on Google+

Home   About   Blog   Careers   Contact