messing with pypy sandboxing

appcfg.py

# -*- coding: utf-8 -*-
from helpers import Form, CharField


class ConfigForm(Form):
    key = CharField('Twitter Consumer Key', max_length=255, required=True)
    secret = CharField('Twitter Consumer Secret', max_length=255, required=True)

    def to_settings(self, settings):
        data = self.cleaned_data
        auth = list(settings.get('AUTHENTICATION_BACKENDS', []))
        auth.append('social_auth.backends.twitter.TwitterBackend')
        settings['AUTHENTICATION_BACKENDS'] = auth
        settings['TWITTER_CONSUMER_KEY'] = data['key']
        settings['TWITTER_CONSUMER_SECRET'] = data['secret']
        return settings

ConfigForm.expose()

helpers.py

# -*- coding: utf-8 -*-
import simplejson as json
import sys
import argparse

# LIB

def run(cls):
    parser = argparse.ArgumentParser()
    parser.add_argument('action', choices=['getform', 'saveform', 'savesettings'])

    args = parser.parse_args()

    if args.action == 'getform':
        form = cls()
        json.dump(form.render(), sys.stdout)
    elif args.action == 'saveform':
        data = json.load(sys.stdin)
        form = cls(data)
        output = {
            'errors': None,
            'data': None,
        }
        if form.is_valid():
            output['data'] = form.save()
        else:
            output['errors'] = form.errors
        json.dump(output, sys.stdout)
    elif args.action == 'savesettings':
        data = json.load(sys.stdin)

        form = cls(data['values'])
        output = form.to_settings(data['settings'])
        json.dump(output, sys.stdout)


def build_form_field(id, field_type, max_length=None, label=None, required=False):
    #TODO: VALIDATION!
    return {
        'id': id,
        'field_type': field_type,
        'max_length': max_length,
        'label': label,
        'required': required,
    }


class Error(Exception):
    pass


class Field(object):
    pass


class CharField(Field):
    def __init__(self, label, max_length, required=True):
        self.label = label
        self.max_length = max_length
        self.required = required

    def clean(self, value):
        if self.required and not value:
            raise Error("Field required")
        if self.max_length and len(value) > self.max_length:
            raise Error("Max length %s exceeded" % self.max_length)
        return value

    def render(self):
        return {
            'label': self.label,
            'max_length': self.max_length,
            'required': self.required
        }


class FormMeta(type):
    def __new__(cls, name, bases, attrs):
        fields = []
        for key, value in attrs.items():
            if isinstance(value, Field):
                fields.append((key, value))
        attrs['_fields'] = fields
        return super(FormMeta, cls).__new__(cls, name, bases, attrs)


class Form(object):
    __metaclass__ = FormMeta

    def __init__(self, data=None):
        self.data = data

    def render(self):
        form = []
        for name, field in self._fields:
            form.append((name, field.render()))
        return form

    def is_valid(self):
        self.cleaned_data = {}
        self.errors = {}
        try:
            self.clean()
        except Error, e:
            if None not in self.errors:
                self.errors[None] = []
            self.errors[None].append(e.message)
        return not self.errors

    def clean(self):
        for name, field in self._fields:
            value = self.data.get(name, None)
            try:
                self.cleaned_data[value] = field.clean(value)
            except Error, e:
                if name not in self.errors:
                    self.errors[name] = []
                self.errors[name].append(e.message)

    def to_settings(self, settings):
        return settings

    def save(self):
        return self.cleaned_data

    @classmethod
    def expose(cls):
        run(cls)

runner.sh

pypy_interact.py --tmp=/folder/containing/app-py-and-helpers.py/ pypy-c-sandbox /tmp/appcfg.py getform