Satchmo is based on the Django framework. More accurately, it is loosely coupled to Django through several external Django plugins. For example, registration functionality is extended through the django_registration external interface, installed as a separate egg in the Python distribution directory. Satchmo makes calls to this extension, leaving Django code untouched.

Compare this to Drupal registration changes, where source code is wedged into the existing framework, applying deep back end database schema changes, as well as code changes throughout the framework. The changes are irreversible, and if they fail, you’re SOL. Look under the hood of Drupal, and you see a tangle of database calls, auth and group checking calls, intertwined around back end logic. It’s not pretty, which is why it’s so hard to maintain and upgrade over time.

The Satchmo/Django coupling is not perfect. If you mismatch incompatible versions of Django plugins to Satchmo, or other applications, cryptic messages can appear from either side, pointing back to code compiled elsewhere and placed in your Python distro. This makes it difficult to trace back, even if you vaguely know where the failure point is.

But this is the worst problem Satchmo has presented to me so far. I can certainly live with that, compared to digging through many chunks of Drupal framework source code and database schema backups to figure out why a recent patch broke authentication, how group permissions were changed, etc.

Satchmo takes full advantage of all of the juicy Django goodness that makes web framework development fun again: built-in internationalization and localization all the way down to currency handling and language choices in templates, built-in registration, email verification and customer account management, built-in form data validation, seamless form-to-database data entry.

This is a revolutionary, much needed improvement in the Open Source store front choices. Now all we need is an Open Source back end inventory system, and a very functional Open Source phone bank system based on Asterisk, with Python wrappers, and life would be wonderful.

Gloria

Want to get more familiar with Python? Want to participate in shaping this community, and helping to drive the effort behind new libraries and modules? Want to do something fun and new in the Open Spaces and code sprints? Be sure to be there in 2010. I think it’s going to be a unique, interesting and most spectacular year for PyCon, and I’d really like many women on this list to be a part of this great event.

I know, it’s late for my time zone, and you must be thinking that I’m juiced up on Club Mate right now. Maybe I am, but I was excited about this well before the Mate. I am a bit more involved this year, reviewing talks, discussing some possibilities for new types of Open Space events and code sprints, poking my head into various discussions, etc. It’s getting exciting, but it will be even better if more women show up this year, I guarantee this (HINT HINT).

If you want to come, but can’t afford it, don’t let this stop you! Contact me and I’ll put you in touch with organizers who may be able to help you get to PyCon this year.

Yes, I’m flying. How? No, not Mate. You know how:
http://xkcd.com/353/

Gloria

(1) Find related web sites and drop relevant strategic links on those sites without “spamming”.
(2) Create an online social app/blog presence for this company, announcing new products, philanthropic events, etc. for this company.
(3) Follow accounts at Facebook, MySpace, product blogs, etc. Help set up the look and feel of these sites (working alongside a writer, a designer, and a software developer).
(4) Help us build this presence in creative ways: event photo slideshows, podcasting interviews of the owners, the technical aspects of the company, etc.

Please submit a resume and some examples of your work online. Also give me an example of how you would promote such a situation. Creativity is definitely encouraged:

I am handling the system admin and software design/development. Over the next few months, I’ll be taking it in new directions, by bringing in a free Python apprenticeship training group, and using this site as training ground for people new to Python. This will bring it some social exposure from the tecchie direction. How and where would you discuss this unique approach of growing a business while providing a public service?

Please send email to gloriajw_66, at the address yahoo dot com

Thank you, and good luck!
Gloria

PS: Working alongside me means this job _always_ has the opportunity to morph in a more technical direction, if you so choose. This straddles many disciplines, and can turn out to be quite fun if you wish to expand your current knowledge.

I did a tutorial on browser-to-database web development in Python, using components from various packages instead of one framework. I found myself and Mark Ramm giving our audiences a common message about frameworks in general, which was (1) each framework has limitations, (2) know these limitations before running off to use them. It was comforting to know that I am not the only one trying to convey this message.

I wasn’t quite sure how long my tutorial would run, so the PyOhio folks were kind enough to give me a room for an entire afternoon. It took about three hours, and was great fun.

I’ll attach all slides, links, and code. But there’s the summary of it all.

I took weather data from the University of Delaware, air temperatures from around the world ranging from 1900 to 2008. I pulled the data into both SqlAlchemy/Postgres, and MongoDB (a BSON-based key-value object store).

I then used CherryPy to serve up the data. My templates are written in web.py template, generating Google Map data.

The first CherryPy daemon takes longitude and latitude, and allows you to choose between Postgres or Mongo:

http://www.pythonpeople.net/gmaps/squarearea?year=1900&month=0&zoom=7&centerlat=40.90&centerlong=-80.50

http://www.pythonpeople.net/gmaps/squarearea?year=1900&month=0&zoom=7&centerlat=40.90&centerlong=-80.50&mongo=1

The second daemon provided a simple form, accepting zip codes, and referencing a database which maps zip codes to longitude and latitude.

Feel free to play with the links for a bit longer. They will be coming down in the next month or so.

The code and data, including all CSV load code and scripts, exists here:

http://www.pythonpeople.net/pyohio_src

Shoot me an email for the login and password: gloriajw_66 at yahoo dot com

This is an excellent web app example for learning purposes.

The tutorial is also somewhere on BlipTV, I am told.

Enjoy, play, ask questions.

Gloria

“We are in a comparatively irreverent industry. I remember seeing a couple of people swear onstage at the Webbies back in 2005, for example. We tend, as a whole, to lean toward more radical politics, more speaking your mind, and more irreverent humor — across all genders — as compared to other industries. The relative permissiveness in our industry partially accounts for why you might see something that pushes “the line” on stage at a web technologies conference than say, at a professional conference of another type. This needs to be kept in mind when the term “professionalism” is used rhetorically in these conversations.

So one thing that I think is true, is that we will continually be dancing toward “the line”, and not just on issues of gender, but also politics and other areas. And because of this, we do need to continually revisit what the boundaries of “offense” are or might be. Hopefully this will result not in fear-based non-expressive atmospheres, but in a civilized atmosphere where we are sensitive to our audiences, and they are sensitive to us as we express ourselves with whatever level of irreverence or forthrightness we choose. As a part of the inclusive atmosphere, it is critical that that inclusiveness works in all directions, and that all stakeholders keep a good faith attitude of questioning the content and context of their actions, and also the character and motives of their “offense”, or whatever reactions might be invoked.

The uber-goal, with this reflective consideration of expressers and reactors, is that we are able to openly discuss all factors at any time. That we have a safe environment for people to express and feedback. That includes allowing room for people to offend, allowing room for people to express their discomfort, and allowing room for people to apologize, be heard, and agree or disagree. Everything will work out for the best if that is the atmosphere of discourse that we support. We wont always agree, but we must put as much effort as possible into seeing the world from each other’s viewpoint.”

–Carlos Abler

Here’s a link to letters by conference organizer and offensive speaker in response, and discussion.

Let’s start with the Launching Your Own Startup panel. The quote I can’t stop remembering is “Entrepreneurship is like jumping off a cliff and building a plane on the way down.” Also, that failure has lots of virtues: it makes you smarter, more attractive to funders, can make you fearless and more willing to jump that cliff. They all heartily encouraged anyone interested in starting a business to go for it. On a practical level, they all made sure their ideas had legs before quitting day jobs or abandoning previous businesses. They recommended an iterative business model with some focus on revenue from day one; recommended bootstrapping then going for advisors and then angel funding before going for VC money. They stressed researching VCs very, very thoroughly to make sure they understood your product and market or community, then selecting one you have a viable, personal connection with. They also recommended having business partners, for the value of differing strengths, but also because it makes you more attractive to funders, helps with your power balance with them. They all recommended Steve Blank’s book Four Steps to the Epiphany.

The next panel I attended was called The Feminine Mystique. (See this for the historical context of that title.) Essentially, this one was about the level of satisfaction women are finding in the life of technology work. Issues of work/life balance, of qualities of nurturing being undervalued in the workplace were explored. —There was a nuanced discussion at this point, by the way. We recognized that not all women are nurturing, etc. The value of mentoring was explained thoroughly, however, both in the men-tee experiences of the eminently successful panelists and as an undervalued management tool used to grow workers. We discussed promoting tools for shared parenting and increased time off for fathering, that had been introduced twenty years ago and were succeeding but lost favor in the rabid conservatism of the past decade - job-sharing, for example. We discussed the need to consider ourselves experts with less qualification than studies show we currently do, to create more parity with the way men determine themselves experts, and then act on that accordingly. (Men will see a list of requirements for a job they’re interested in, know they have only two out of twelve, for example, and confidently apply; women won’t unless they have ten, for example.) I feel however, that a little of both is in order on this issue: it’s important to re-define “expert” so that men who may be undeservedly claiming the right to that title are discouraged, just as it’s important for women who aren’t doing so to be encouraged. This translates into behaviors like speaking in meetings, etc.

The Video Activism panel. The panelists were from Youtube’s non-profit program, Witness.org and Free Range Studios. Basically they discussed different methods of persuading people to act, but their relationships to video were very different. I thought the most interesting aspect of the discussion was the striking contrast between Witness’ and Free Range’s work specifically. Witness is a global human rights organization, while Free Range is a San Francisco-based design shop that provides creative services for nonprofits and socially responsible companies. Witness often works with user-uploaded video, it’s often brutal and they don’t necessarily have control over issues of style or sound or pacing, whereas Free Range is in the business of crafting and producing video as part of larger, sophisticated campaigns. Both are very effective organizations, both discussed tactics for targeting people in concentric circles from most passionate and likely to act to least aware and engaged, but with widely differing parameters. Witness gave an example of a very graphic video in which Egyptian police beating a man was produced and released by the police themselves in order to intimidate others, but it reached the notice of human rights bloggers and so has been widely used as a resistance tool. It’s this combination of raw footage used by bloggers that creates the successful activism in Witness’s case. (Witness licenses footage on a sliding scale from their archive of about 3,000 hours of video; it’s frequently used by documentary filmmakers, journalists, grad students, etc.) Whereas the Free Range spokeperson gave an example of using stop-motion video, which is time-consuming and a little expensive to produce, in a campaign called save the bay. It was also very successful: they achieved their targeted number of email signups and their funding goals for an environmental impact study. But they were able to control every aspect of the video and the microsite on which it’s viewed.

I listened to a bit of the Social Media ROI panel, which hit topics like how you measure success depends upon how you frame your criteria, slightly tautological but the example given illustrates the power of the point. Presidential candidate Ron Paul used social media to try to win the Republican party’s nomination but didn’t (obviously). What they proposed, I believe based on interviews with Mr. Paul, is that he didn’t believe or intend to win, though of course he would’ve welcomed that outcome. What he wanted was to make sure certain issues were part of the debate and by using social media, he achieved exactly that. And hence, success. I only listened to a bit, though, because I was getting ready to travel to the after-party, which I attended and thoroughly enjoyed. The bar was laid back, they provided meat, vegan & veggie pizzas, it was a comfortable number of people, the discussions were friendly, and I met a journalist who works for the Huffington Post. On top of meeting five or six women programmers and Deanna Zandt, a prominent feminist organizer and technology consultant in New York who turned out to be one of those really nice, fun, shots-for-all-buyers. Good times, chix. Maybe we should try to get involved with next year’s summit, as an entity. 

Links:

Women Who Tech Podcasts

Witness

That’s Not Cool

Knight News Challenge

RAD Campaign

Now Public

Deanna Zandt

RiseUp

The Story of Stuff

Free Range Studios

Berrett-Koehler Publishing

http://fyi.oreilly.com/2009/05/women-in-tech-rock-join-our-mo.html

The discount code can be found at this link.

Gloria

I was very nervous to begin with but all in all I think it went well. We tried to hit on some things that we feel would help with getting more women into the Rails Community specifically as well as in the development world period. We only gave 5 minutes to the CouchDB talk mostly because we personally (Myself, Sarah and Lori) would like to move on. I did tell David Hanson to please keep his mouth shut next time but I did that in a light-hearted way to try and lighten the mood a bit. I hope he took it that way.

My biggest whoops was that I actually said and believed I didn’t know Matt but after the talk he came over and pointed out that I DID indeed know him. In fact, we have had a very lengthy conversation about women in development in the past (I do remember him and did as soon as I connected his face with his name). Anyway I felt like a jackass.

I want to do a more lengthy recap of the whole panel and the various discussions that took place before and after but for now I would like a reprieve. I am a bit on the drained side and if I tried to cover everything just now, I wouldn’t do a very good job. So give me a day or two to get my write up out.. maybe Sarah and Lori will have more energy to do the post than I do just now.

I do want to say thank you to everyone who came to the panel. Including all the Ruby/Rails big wigs. ;-)

Cheers
Desi

http://railsbridge.org/

We’ve been fortunate to have an outstanding, welcoming Python community driving the tone and the quality of events from PyCon, down to the statewide and local user groups. We don’t yet have a need for such a bridge group, and I hope we never need one. But it’s great to see one form quickly where it’s needed, and to see familiar names associated with it. More power to you.

Gloria

But if you’re looking for a small, easily manageable and extremely dynamic ReST dispatching solution without the heft of an entire web framework, I’m about to show you how CherryPy can help you in three different ways, depending on your model.

Assuming this mapping:

HTTP GET or HEAD = DB Read
HTTP POST = DB update
HTTP PUT = DB insert
HTTP DELETE = DB delete

Let’s also standardize on one common method across all examples, for determining the HTTP request type, and matching it to the function of the same name. Here is the full code snippet for accomplishing this task:

methods = ('OPTIONS','GET','HEAD','POST',
'PUT','DELETE','TRACE','CONNECT')

if cherrypy.request.method not in self.methods:
    raise cherrypy.HTTPError(400,'Bad Request')

# If request method is HEAD, return the page handler
# for GET, and let CherryPy take care of dropping
# the response body
method = cherrypy.request.method

if cherrypy.request.method == "HEAD":
    method = "GET"

http_method = getattr(self,method)

#print "HTTP Method: %s" % method

result=(http_method)(args,kwargs)

In our examples, we’re going to shorten this to:

http_method = getattr(self.m,cherrypy.request.method)
return (http_method)(args,kwargs)

All of this essentially determines how HTTP was called (GET/PUT/POST/DELETE), and calls the method in a class which exactly matches this name (self.GET(), self.PUT(), etc)
When you see this code, know that it’s just the HTTP method resolving code.

Now for the fun. Let’s look at the dispatcher options we have.

Way 1: A hard-coded URL pointing to fixed resources:

CherryPy can be used in a manner similar to this to establish a fixed URL, and corresponding resources, driven from predefined classes instantiated in the ‘root’ hierarchy:

import cherrypy

class ReSTPaths1:
	@cherrypy.expose
	def index(self):
		http_method = getattr(self,cherrypy.request.method)
		return (http_method)()

	def GET(self):
		return "In GET 1.."

class ReSTPaths2:
	@cherrypy.expose
	def index(self):
		http_method = getattr(self,cherrypy.request.method)
		return (http_method)()

	def GET(self):
		return "In GET 2.."

class ReSTPaths3:
	@cherrypy.expose
	def index(self,client_id=None):
		http_method = getattr(self,cherrypy.request.method)
		return (http_method)(client_id)

	def GET(self,client_id=None):
		return "IN Get 3, your client_id is %s\n" % (client_id)

cherrypy.server.socket_port=8081

root=ReSTPaths1()
root.client = ReSTPaths2()
root.client.address = ReSTPaths3()
cherrypy.quickstart(root)

Once this is running, the URL to invoke it looks like this:
http://localhost:8081/
http://localhost:8081/client/
http://localhost:8081/client/address/
http://localhost:8081/client/address/?client_id=34567
http://localhost:8081/client/address/34567

Output looks something like this:

In GET 1..
In GET 2..
IN Get 3, your client_id is None

If you’re new to CherryPy or Python in general, I’ll reiterate for you how we are calling the GET method in our class.

When we issue this request, we’re issuing what HTTP calls a GET request:

http://localhost:8081/

The CherryPy service above, listening on port 8081, calls the index() method on the root class. The root class was set to:

root=ReSTPaths1()

at the bottom of that file. The index() method from the ReSTPaths1 Class looks like this, at the top of that file:

	def index(self):
		http_method = getattr(self,cherrypy.request.method)
		return (http_method)()

If we were to insert a print cherrypy.request.method statement before the return, we would see it set to “GET”.

getattr simply says: “get me the function name in self, matching the string “GET”.
it returns a reference to self.GET(), which is set directly below the index:

	def GET(self):
		return "In GET 1.."

Notice that the index() method has a @cherrrypy.expose decorator above it. This makes the index method callable by the public. The GET method does not have it, which means we could never invoke the GET method by typing:

http://localhost:8081/GET

If you try this, you’ll get a 404 Not Found error, because it’s not visible through the CherryPy interface.

GET() has to be invoked through index(), which means GET can only be called if an HTTP GET request is issued. If we posted form data to this same URL from, say, a form entry asking people for data input, we would need to add a POST method to this ReSTPaths1() class, to receive the POST data entered in the form fields.

Now back to our example:

In this example, no part of the URL or associated resources are dynamic, in either initialization or run time. This is fine, and suits the needs of most ReSTful CRUD interfaces.

Way 2: URL paths and associated components dynamically set once, upon dispatcher init/startup:

Now let’s say we want to determine the contents of the root, and therefore the URLs and associated resources for our ReSTful interface, dynamically during initialization/startup.

We can assign the root setting by using a Python metaclass to generate classes in our CherryPy startup code, and set the root components to each generated class. This goes beyond the average needs for CRUD access, but it’s such a nice implementation that I must show it off:

import cherrypy

class MetaCRUD(type):
	@cherrypy.expose
	def index(cls):
		http_method = getattr(cls,cherrypy.request.method)
		return (http_method)()

	def GET(cls): return "In class ", cls.__name__, ', received a GET request.'

	def PUT(cls): return "In class ", cls.__name__, ', received a PUT request.'

	def POST(cls): return "In class ", cls.__name__, ', received a POST request.'

	def DELETE(cls): return "In class ", cls.__name__, ', received a DELETE request.'

baseCRUD = MetaCRUD('baseCRUD',(),{})
root = baseCRUD

dynamic_class = {}

for d in ['legacy_dbi','new_dbi','some_other_dbi']:
	dynamic_class[d] = MetaCRUD(d,(),{})
	setattr(root,d,dynamic_class[d])

cherrypy.server.socket_port=8081
cherrypy.quickstart(root)

Here we’re using a metaclass, with CherryPy exposed methods, to generate a dictionary of dynamic classes. We set the root.classname = the_new_class by using the setattr() method.

After initialization, URL components and resources are fixed in this model. But wow, the awesome power we have during initialization, in 28 lines really rocks. I wrote this in 30 minutes, and realized again why I am so head-over-heels in love with this language.

When we hit these URLs:

http://localhost:8081/
http://localhost:8081/legacy_dbi/
http://localhost:8081/new_dbi/
http://localhost:8081/some_other_dbi/

We see this output:

In class baseCRUD, received a GET request.
In class legacy_dbi, received a GET request.
In class new_dbi, received a GET request.
In class some_other_dbi, received a GET request.

Let’s issue a POST request via curl, on the command line. The response is returned:

[gloriajw@g-monster ~]$ curl http://localhost:8081/some_other_dbi/ -d ""
In class some_other_dbi, received a POST request.

This model could be used for, say, reading the contents of the Postgres template1 databases list or the mysql ’show databases’ command, and auto-generating a ReSTful CRUD interface for each. Access of each resources can be controlled via HTTP Auth methods. This is a great solution to providing, and restricting, legacy database access for new processes through a standard interface.

Way 3: Live, ever-dynamic determination of URL and associated component:

Some ReSTful URL models may need to be ‘run-time dynamic’, especially in the case where databases are dynamically created, and the associated resources per new database could vary. There is a simple example of a dynamic URL and resource model:

import cherrypy
import pprint

class ReSTPaths:
	@cherrypy.expose
	def __init__(self):
		pass

	@cherrypy.expose
	def client(self,*args,**kwargs):
		return "Your HTTP method was %s. Your args are: %s and your kwargs are: %s\n" \
		% (cherrypy.request.method, pprint.pformat(args), pprint.pformat(kwargs))

	@cherrypy.expose
	def address(self,*args,**kwargs):
		return "Your HTTP method was %s. Your args are: %s and your kwargs are: %s\n" \
		% (cherrypy.request.method, pprint.pformat(args), pprint.pformat(kwargs))

cherrypy.quickstart(ReSTPaths())

This allows for dynamic URLs such as:
http://localhost:8080/client/address/34567
http://localhost:8080/client/address?client_id=34567
http://localhost:8080/address/client?client_id=34567
http://localhost:8080/address/client/34567
http://localhost:8080/address/anything/anything_else

The output from this code looks like this:

Your HTTP method was GET. Your args are: ('address', '34567') and your kwargs are: {}
Your HTTP method was GET. Your args are: ('address',) and your kwargs are: {'client_id': '34567'}
Your HTTP method was GET. Your args are: ('client',) and your kwargs are: {'client_id': '34567'}
Your HTTP method was GET. Your args are: ('client', '34567') and your kwargs are: {}
Your HTTP method was GET. Your args are: ('anything', 'anything_else') and your kwargs are: {}

Notice that we only have keyword args (kwargs) when we pass a named parameter, such as client_id=34567

Let’s try a POST request from curl, on the command line:

[gloriajw@g-monster ~]$ curl -d "something_else=whatever_i_want" http://localhost:8080/address/anything/anything_else
Your HTTP method was POST. Your args are: ('anything', 'anything_else') and your kwargs are: {'something_else': 'whatever_i_want'}

In this code, the sky is the limit. You can place whatever code you like in these methods, dynamically creating classes and resources as needed, letting them only persist until the result is returned. This may add some inefficiency, but in exchange offer more secure network resources.

Code is attached, Enjoy!

Gloria

http://www.devchix.com/wp-content/uploads/2009/04/restfixedargs.py

http://www.devchix.com/wp-content/uploads/2009/04/restmeta.py

http://www.devchix.com/wp-content/uploads/2009/04/restvarargs.py