gcloud 0.0.7 → 0.1.0

data/packages/gsutil/boto/boto/mashups/server.py

@@ -1,395 +0,0 @@
-# Copyright (c) 2006,2007 Mitch Garnaat http://garnaat.org/
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-
-"""
-High-level abstraction of an EC2 server
-"""
-import boto
-import boto.utils
-from boto.mashups.iobject import IObject
-from boto.pyami.config import Config, BotoConfigPath
-from boto.mashups.interactive import interactive_shell
-from boto.sdb.db.model import Model
-from boto.sdb.db.property import StringProperty
-import os
-import StringIO
-
-
-class ServerSet(list):
-
-    def __getattr__(self, name):
-        results = []
-        is_callable = False
-        for server in self:
-            try:
-                val = getattr(server, name)
-                if callable(val):
-                    is_callable = True
-                results.append(val)
-            except:
-                results.append(None)
-        if is_callable:
-            self.map_list = results
-            return self.map
-        return results
-
-    def map(self, *args):
-        results = []
-        for fn in self.map_list:
-            results.append(fn(*args))
-        return results
-
-class Server(Model):
-
-    @property
-    def ec2(self):
-        if self._ec2 is None:
-            self._ec2 = boto.connect_ec2()
-        return self._ec2
-
-    @classmethod
-    def Inventory(cls):
-        """
-        Returns a list of Server instances, one for each Server object
-        persisted in the db
-        """
-        l = ServerSet()
-        rs = cls.find()
-        for server in rs:
-            l.append(server)
-        return l
-
-    @classmethod
-    def Register(cls, name, instance_id, description=''):
-        s = cls()
-        s.name = name
-        s.instance_id = instance_id
-        s.description = description
-        s.save()
-        return s
-
-    def __init__(self, id=None, **kw):
-        Model.__init__(self, id, **kw)
-        self._reservation = None
-        self._instance = None
-        self._ssh_client = None
-        self._pkey = None
-        self._config = None
-        self._ec2 = None
-
-    name = StringProperty(unique=True, verbose_name="Name")
-    instance_id = StringProperty(verbose_name="Instance ID")
-    config_uri = StringProperty()
-    ami_id = StringProperty(verbose_name="AMI ID")
-    zone = StringProperty(verbose_name="Availability Zone")
-    security_group = StringProperty(verbose_name="Security Group", default="default")
-    key_name = StringProperty(verbose_name="Key Name")
-    elastic_ip = StringProperty(verbose_name="Elastic IP")
-    instance_type = StringProperty(verbose_name="Instance Type")
-    description = StringProperty(verbose_name="Description")
-    log = StringProperty()
-
-    def setReadOnly(self, value):
-        raise AttributeError
-
-    def getInstance(self):
-        if not self._instance:
-            if self.instance_id:
-                try:
-                    rs = self.ec2.get_all_instances([self.instance_id])
-                except:
-                    return None
-                if len(rs) > 0:
-                    self._reservation = rs[0]
-                    self._instance = self._reservation.instances[0]
-        return self._instance
-
-    instance = property(getInstance, setReadOnly, None, 'The Instance for the server')
-    
-    def getAMI(self):
-        if self.instance:
-            return self.instance.image_id
-
-    ami = property(getAMI, setReadOnly, None, 'The AMI for the server')
-    
-    def getStatus(self):
-        if self.instance:
-            self.instance.update()
-            return self.instance.state
-
-    status = property(getStatus, setReadOnly, None,
-                      'The status of the server')
-    
-    def getHostname(self):
-        if self.instance:
-            return self.instance.public_dns_name
-
-    hostname = property(getHostname, setReadOnly, None,
-                        'The public DNS name of the server')
-
-    def getPrivateHostname(self):
-        if self.instance:
-            return self.instance.private_dns_name
-
-    private_hostname = property(getPrivateHostname, setReadOnly, None,
-                                'The private DNS name of the server')
-
-    def getLaunchTime(self):
-        if self.instance:
-            return self.instance.launch_time
-
-    launch_time = property(getLaunchTime, setReadOnly, None,
-                           'The time the Server was started')
-
-    def getConsoleOutput(self):
-        if self.instance:
-            return self.instance.get_console_output()
-
-    console_output = property(getConsoleOutput, setReadOnly, None,
-                              'Retrieve the console output for server')
-
-    def getGroups(self):
-        if self._reservation:
-            return self._reservation.groups
-        else:
-            return None
-
-    groups = property(getGroups, setReadOnly, None,
-                      'The Security Groups controlling access to this server')
-
-    def getConfig(self):
-        if not self._config:
-            remote_file = BotoConfigPath
-            local_file = '%s.ini' % self.instance.id
-            self.get_file(remote_file, local_file)
-            self._config = Config(local_file)
-        return self._config
-
-    def setConfig(self, config):
-        local_file = '%s.ini' % self.instance.id
-        fp = open(local_file)
-        config.write(fp)
-        fp.close()
-        self.put_file(local_file, BotoConfigPath)
-        self._config = config
-
-    config = property(getConfig, setConfig, None,
-                      'The instance data for this server')
-
-    def set_config(self, config):
-        """
-        Set SDB based config
-        """
-        self._config = config
-        self._config.dump_to_sdb("botoConfigs", self.id)
-
-    def load_config(self):
-        self._config = Config(do_load=False)
-        self._config.load_from_sdb("botoConfigs", self.id)
-
-    def stop(self):
-        if self.instance:
-            self.instance.stop()
-
-    def start(self):
-        self.stop()
-        ec2 = boto.connect_ec2()
-        ami = ec2.get_all_images(image_ids = [str(self.ami_id)])[0]
-        groups = ec2.get_all_security_groups(groupnames=[str(self.security_group)])
-        if not self._config:
-            self.load_config()
-        if not self._config.has_section("Credentials"):
-            self._config.add_section("Credentials")
-            self._config.set("Credentials", "aws_access_key_id", ec2.aws_access_key_id)
-            self._config.set("Credentials", "aws_secret_access_key", ec2.aws_secret_access_key)
-
-        if not self._config.has_section("Pyami"):
-            self._config.add_section("Pyami")
-
-        if self._manager.domain:
-            self._config.set('Pyami', 'server_sdb_domain', self._manager.domain.name)
-            self._config.set("Pyami", 'server_sdb_name', self.name)
-
-        cfg = StringIO.StringIO()
-        self._config.write(cfg)
-        cfg = cfg.getvalue()
-        r = ami.run(min_count=1,
-                    max_count=1,
-                    key_name=self.key_name,
-                    security_groups = groups,
-                    instance_type = self.instance_type,
-                    placement = self.zone,
-                    user_data = cfg)
-        i = r.instances[0]
-        self.instance_id = i.id
-        self.put()
-        if self.elastic_ip:
-            ec2.associate_address(self.instance_id, self.elastic_ip)
-
-    def reboot(self):
-        if self.instance:
-            self.instance.reboot()
-
-    def get_ssh_client(self, key_file=None, host_key_file='~/.ssh/known_hosts',
-                       uname='root'):
-        import paramiko
-        if not self.instance:
-            print 'No instance yet!'
-            return
-        if not self._ssh_client:
-            if not key_file:
-                iobject = IObject()
-                key_file = iobject.get_filename('Path to OpenSSH Key file')
-            self._pkey = paramiko.RSAKey.from_private_key_file(key_file)
-            self._ssh_client = paramiko.SSHClient()
-            self._ssh_client.load_system_host_keys()
-            self._ssh_client.load_host_keys(os.path.expanduser(host_key_file))
-            self._ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-            self._ssh_client.connect(self.instance.public_dns_name,
-                                     username=uname, pkey=self._pkey)
-        return self._ssh_client
-
-    def get_file(self, remotepath, localpath):
-        ssh_client = self.get_ssh_client()
-        sftp_client = ssh_client.open_sftp()
-        sftp_client.get(remotepath, localpath)
-
-    def put_file(self, localpath, remotepath):
-        ssh_client = self.get_ssh_client()
-        sftp_client = ssh_client.open_sftp()
-        sftp_client.put(localpath, remotepath)
-
-    def listdir(self, remotepath):
-        ssh_client = self.get_ssh_client()
-        sftp_client = ssh_client.open_sftp()
-        return sftp_client.listdir(remotepath)
-
-    def shell(self, key_file=None):
-        ssh_client = self.get_ssh_client(key_file)
-        channel = ssh_client.invoke_shell()
-        interactive_shell(channel)
-
-    def bundle_image(self, prefix, key_file, cert_file, size):
-        print 'bundling image...'
-        print '\tcopying cert and pk over to /mnt directory on server'
-        ssh_client = self.get_ssh_client()
-        sftp_client = ssh_client.open_sftp()
-        path, name = os.path.split(key_file)
-        remote_key_file = '/mnt/%s' % name
-        self.put_file(key_file, remote_key_file)
-        path, name = os.path.split(cert_file)
-        remote_cert_file = '/mnt/%s' % name
-        self.put_file(cert_file, remote_cert_file)
-        print '\tdeleting %s' % BotoConfigPath
-        # delete the metadata.ini file if it exists
-        try:
-            sftp_client.remove(BotoConfigPath)
-        except:
-            pass
-        command = 'sudo ec2-bundle-vol '
-        command += '-c %s -k %s ' % (remote_cert_file, remote_key_file)
-        command += '-u %s ' % self._reservation.owner_id
-        command += '-p %s ' % prefix
-        command += '-s %d ' % size
-        command += '-d /mnt '
-        if self.instance.instance_type == 'm1.small' or self.instance_type == 'c1.medium':
-            command += '-r i386'
-        else:
-            command += '-r x86_64'
-        print '\t%s' % command
-        t = ssh_client.exec_command(command)
-        response = t[1].read()
-        print '\t%s' % response
-        print '\t%s' % t[2].read()
-        print '...complete!'
-
-    def upload_bundle(self, bucket, prefix):
-        print 'uploading bundle...'
-        command = 'ec2-upload-bundle '
-        command += '-m /mnt/%s.manifest.xml ' % prefix
-        command += '-b %s ' % bucket
-        command += '-a %s ' % self.ec2.aws_access_key_id
-        command += '-s %s ' % self.ec2.aws_secret_access_key
-        print '\t%s' % command
-        ssh_client = self.get_ssh_client()
-        t = ssh_client.exec_command(command)
-        response = t[1].read()
-        print '\t%s' % response
-        print '\t%s' % t[2].read()
-        print '...complete!'
-
-    def create_image(self, bucket=None, prefix=None, key_file=None, cert_file=None, size=None):
-        iobject = IObject()
-        if not bucket:
-            bucket = iobject.get_string('Name of S3 bucket')
-        if not prefix:
-            prefix = iobject.get_string('Prefix for AMI file')
-        if not key_file:
-            key_file = iobject.get_filename('Path to RSA private key file')
-        if not cert_file:
-            cert_file = iobject.get_filename('Path to RSA public cert file')
-        if not size:
-            size = iobject.get_int('Size (in MB) of bundled image')
-        self.bundle_image(prefix, key_file, cert_file, size)
-        self.upload_bundle(bucket, prefix)
-        print 'registering image...'
-        self.image_id = self.ec2.register_image('%s/%s.manifest.xml' % (bucket, prefix))
-        return self.image_id
-
-    def attach_volume(self, volume, device="/dev/sdp"):
-        """
-        Attach an EBS volume to this server
-
-        :param volume: EBS Volume to attach
-        :type volume: boto.ec2.volume.Volume
-
-        :param device: Device to attach to (default to /dev/sdp)
-        :type device: string
-        """
-        if hasattr(volume, "id"):
-            volume_id = volume.id
-        else:
-            volume_id = volume
-        return self.ec2.attach_volume(volume_id=volume_id, instance_id=self.instance_id, device=device)
-
-    def detach_volume(self, volume):
-        """
-        Detach an EBS volume from this server
-
-        :param volume: EBS Volume to detach
-        :type volume: boto.ec2.volume.Volume
-        """
-        if hasattr(volume, "id"):
-            volume_id = volume.id
-        else:
-            volume_id = volume
-        return self.ec2.detach_volume(volume_id=volume_id, instance_id=self.instance_id)
-
-    def install_package(self, package_name):
-        print 'installing %s...' % package_name
-        command = 'yum -y install %s' % package_name
-        print '\t%s' % command
-        ssh_client = self.get_ssh_client()
-        t = ssh_client.exec_command(command)
-        response = t[1].read()
-        print '\t%s' % response
-        print '\t%s' % t[2].read()
-        print '...complete!'

data/packages/gsutil/boto/boto/mturk/__init__.py

@@ -1,23 +0,0 @@
-# Copyright (c) 2006,2007 Mitch Garnaat http://garnaat.org/
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-
-

data/packages/gsutil/boto/boto/mturk/connection.py

@@ -1,1027 +0,0 @@
-# Copyright (c) 2006,2007 Mitch Garnaat http://garnaat.org/
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-
-import xml.sax
-import datetime
-import itertools
-
-from boto import handler
-from boto import config
-from boto.mturk.price import Price
-import boto.mturk.notification
-from boto.connection import AWSQueryConnection
-from boto.exception import EC2ResponseError
-from boto.resultset import ResultSet
-from boto.mturk.question import QuestionForm, ExternalQuestion, HTMLQuestion
-
-
-class MTurkRequestError(EC2ResponseError):
-    "Error for MTurk Requests"
-    # todo: subclass from an abstract parent of EC2ResponseError
-
-
-class MTurkConnection(AWSQueryConnection):
-
-    APIVersion = '2012-03-25'
-
-    def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
-                 is_secure=True, port=None, proxy=None, proxy_port=None,
-                 proxy_user=None, proxy_pass=None,
-                 host=None, debug=0,
-                 https_connection_factory=None):
-        if not host:
-            if config.has_option('MTurk', 'sandbox') and config.get('MTurk', 'sandbox') == 'True':
-                host = 'mechanicalturk.sandbox.amazonaws.com'
-            else:
-                host = 'mechanicalturk.amazonaws.com'
-        self.debug = debug
-
-        AWSQueryConnection.__init__(self, aws_access_key_id,
-                                    aws_secret_access_key,
-                                    is_secure, port, proxy, proxy_port,
-                                    proxy_user, proxy_pass, host, debug,
-                                    https_connection_factory)
-
-    def _required_auth_capability(self):
-        return ['mturk']
-
-    def get_account_balance(self):
-        """
-        """
-        params = {}
-        return self._process_request('GetAccountBalance', params,
-                                     [('AvailableBalance', Price),
-                                      ('OnHoldBalance', Price)])
-
-    def register_hit_type(self, title, description, reward, duration,
-                          keywords=None, approval_delay=None, qual_req=None):
-        """
-        Register a new HIT Type
-        title, description are strings
-        reward is a Price object
-        duration can be a timedelta, or an object castable to an int
-        """
-        params = dict(
-            Title=title,
-            Description=description,
-            AssignmentDurationInSeconds=self.duration_as_seconds(duration),
-            )
-        params.update(MTurkConnection.get_price_as_price(reward).get_as_params('Reward'))
-
-        if keywords:
-            params['Keywords'] = self.get_keywords_as_string(keywords)
-
-        if approval_delay is not None:
-            d = self.duration_as_seconds(approval_delay)
-            params['AutoApprovalDelayInSeconds'] = d
-
-        if qual_req is not None:
-            params.update(qual_req.get_as_params())
-
-        return self._process_request('RegisterHITType', params,
-                                     [('HITTypeId', HITTypeId)])
-
-    def set_email_notification(self, hit_type, email, event_types=None):
-        """
-        Performs a SetHITTypeNotification operation to set email
-        notification for a specified HIT type
-        """
-        return self._set_notification(hit_type, 'Email', email,
-                                      'SetHITTypeNotification', event_types)
-
-    def set_rest_notification(self, hit_type, url, event_types=None):
-        """
-        Performs a SetHITTypeNotification operation to set REST notification
-        for a specified HIT type
-        """
-        return self._set_notification(hit_type, 'REST', url,
-                                      'SetHITTypeNotification', event_types)
-
-    def set_sqs_notification(self, hit_type, queue_url, event_types=None):
-        """
-        Performs a SetHITTypeNotification operation so set SQS notification
-        for a specified HIT type. Queue URL is of form:
-        https://queue.amazonaws.com/<CUSTOMER_ID>/<QUEUE_NAME> and can be
-        found when looking at the details for a Queue in the AWS Console
-        """
-        return self._set_notification(hit_type, "SQS", queue_url,
-                                      'SetHITTypeNotification', event_types)
-
-    def send_test_event_notification(self, hit_type, url,
-                                     event_types=None,
-                                     test_event_type='Ping'):
-        """
-        Performs a SendTestEventNotification operation with REST notification
-        for a specified HIT type
-        """
-        return self._set_notification(hit_type, 'REST', url,
-                                      'SendTestEventNotification',
-                                      event_types, test_event_type)
-
-    def _set_notification(self, hit_type, transport,
-                          destination, request_type,
-                          event_types=None, test_event_type=None):
-        """
-        Common operation to set notification or send a test event
-        notification for a specified HIT type
-        """
-        params = {'HITTypeId': hit_type}
-
-        # from the Developer Guide:
-        # The 'Active' parameter is optional. If omitted, the active status of
-        # the HIT type's notification specification is unchanged. All HIT types
-        # begin with their notification specifications in the "inactive" status.
-        notification_params = {'Destination': destination,
-                               'Transport': transport,
-                               'Version': boto.mturk.notification.NotificationMessage.NOTIFICATION_VERSION,
-                               'Active': True,
-                               }
-
-        # add specific event types if required
-        if event_types:
-            self.build_list_params(notification_params, event_types,
-                                   'EventType')
-
-        # Set up dict of 'Notification.1.Transport' etc. values
-        notification_rest_params = {}
-        num = 1
-        for key in notification_params:
-            notification_rest_params['Notification.%d.%s' % (num, key)] = notification_params[key]
-
-        # Update main params dict
-        params.update(notification_rest_params)
-
-        # If test notification, specify the notification type to be tested
-        if test_event_type:
-            params.update({'TestEventType': test_event_type})
-
-        # Execute operation
-        return self._process_request(request_type, params)
-
-    def create_hit(self, hit_type=None, question=None, hit_layout=None,
-                   lifetime=datetime.timedelta(days=7),
-                   max_assignments=1,
-                   title=None, description=None, keywords=None,
-                   reward=None, duration=datetime.timedelta(days=7),
-                   approval_delay=None, annotation=None,
-                   questions=None, qualifications=None,
-                   layout_params=None, response_groups=None):
-        """
-        Creates a new HIT.
-        Returns a ResultSet
-        See: http://docs.amazonwebservices.com/AWSMechTurk/2012-03-25/AWSMturkAPI/ApiReference_CreateHITOperation.html
-        """
-
-        # Handle basic required arguments and set up params dict
-        params = {'LifetimeInSeconds':
-                      self.duration_as_seconds(lifetime),
-                  'MaxAssignments': max_assignments,
-                 }
-
-        # handle single or multiple questions or layouts
-        neither = question is None and questions is None
-        if hit_layout is None:
-            both = question is not None and questions is not None
-            if neither or both:
-                raise ValueError("Must specify question (single Question instance) or questions (list or QuestionForm instance), but not both")
-            if question:
-                questions = [question]
-            question_param = QuestionForm(questions)
-            if isinstance(question, QuestionForm):
-                question_param = question
-            elif isinstance(question, ExternalQuestion):
-                question_param = question
-            elif isinstance(question, HTMLQuestion):
-                question_param = question
-            params['Question'] = question_param.get_as_xml()
-        else:
-            if not neither:
-                raise ValueError("Must not specify question (single Question instance) or questions (list or QuestionForm instance) when specifying hit_layout")
-            params['HITLayoutId'] = hit_layout
-            if layout_params:
-                params.update(layout_params.get_as_params())
-
-        # if hit type specified then add it
-        # else add the additional required parameters
-        if hit_type:
-            params['HITTypeId'] = hit_type
-        else:
-            # Handle keywords
-            final_keywords = MTurkConnection.get_keywords_as_string(keywords)
-
-            # Handle price argument
-            final_price = MTurkConnection.get_price_as_price(reward)
-
-            final_duration = self.duration_as_seconds(duration)
-
-            additional_params = dict(
-                Title=title,
-                Description=description,
-                Keywords=final_keywords,
-                AssignmentDurationInSeconds=final_duration,
-                )
-            additional_params.update(final_price.get_as_params('Reward'))
-
-            if approval_delay is not None:
-                d = self.duration_as_seconds(approval_delay)
-                additional_params['AutoApprovalDelayInSeconds'] = d
-
-            # add these params to the others
-            params.update(additional_params)
-
-        # add the annotation if specified
-        if annotation is not None:
-            params['RequesterAnnotation'] = annotation
-
-        # Add the Qualifications if specified
-        if qualifications is not None:
-            params.update(qualifications.get_as_params())
-
-        # Handle optional response groups argument
-        if response_groups:
-            self.build_list_params(params, response_groups, 'ResponseGroup')
-
-        # Submit
-        return self._process_request('CreateHIT', params, [('HIT', HIT)])
-
-    def change_hit_type_of_hit(self, hit_id, hit_type):
-        """
-        Change the HIT type of an existing HIT. Note that the reward associated
-        with the new HIT type must match the reward of the current HIT type in
-        order for the operation to be valid.
-
-        :type hit_id: str
-        :type hit_type: str
-        """
-        params = {'HITId': hit_id,
-                  'HITTypeId': hit_type}
-
-        return self._process_request('ChangeHITTypeOfHIT', params)
-
-    def get_reviewable_hits(self, hit_type=None, status='Reviewable',
-                            sort_by='Expiration', sort_direction='Ascending',
-                            page_size=10, page_number=1):
-        """
-        Retrieve the HITs that have a status of Reviewable, or HITs that
-        have a status of Reviewing, and that belong to the Requester
-        calling the operation.
-        """
-        params = {'Status': status,
-                  'SortProperty': sort_by,
-                  'SortDirection': sort_direction,
-                  'PageSize': page_size,
-                  'PageNumber': page_number}
-
-        # Handle optional hit_type argument
-        if hit_type is not None:
-            params.update({'HITTypeId': hit_type})
-
-        return self._process_request('GetReviewableHITs', params,
-                                     [('HIT', HIT)])
-
-    @staticmethod
-    def _get_pages(page_size, total_records):
-        """
-        Given a page size (records per page) and a total number of
-        records, return the page numbers to be retrieved.
-        """
-        pages = total_records / page_size + bool(total_records % page_size)
-        return range(1, pages + 1)
-
-    def get_all_hits(self):
-        """
-        Return all of a Requester's HITs
-
-        Despite what search_hits says, it does not return all hits, but
-        instead returns a page of hits. This method will pull the hits
-        from the server 100 at a time, but will yield the results
-        iteratively, so subsequent requests are made on demand.
-        """
-        page_size = 100
-        search_rs = self.search_hits(page_size=page_size)
-        total_records = int(search_rs.TotalNumResults)
-        get_page_hits = lambda page: self.search_hits(page_size=page_size, page_number=page)
-        page_nums = self._get_pages(page_size, total_records)
-        hit_sets = itertools.imap(get_page_hits, page_nums)
-        return itertools.chain.from_iterable(hit_sets)
-
-    def search_hits(self, sort_by='CreationTime', sort_direction='Ascending',
-                    page_size=10, page_number=1, response_groups=None):
-        """
-        Return a page of a Requester's HITs, on behalf of the Requester.
-        The operation returns HITs of any status, except for HITs that
-        have been disposed with the DisposeHIT operation.
-        Note:
-        The SearchHITs operation does not accept any search parameters
-        that filter the results.
-        """
-        params = {'SortProperty': sort_by,
-                  'SortDirection': sort_direction,
-                  'PageSize': page_size,
-                  'PageNumber': page_number}
-        # Handle optional response groups argument
-        if response_groups:
-            self.build_list_params(params, response_groups, 'ResponseGroup')
-
-        return self._process_request('SearchHITs', params, [('HIT', HIT)])
-
-    def get_assignment(self, assignment_id, response_groups=None):
-        """
-        Retrieves an assignment using the assignment's ID. Requesters can only
-        retrieve their own assignments, and only assignments whose related HIT
-        has not been disposed.
-
-        The returned ResultSet will have the following attributes:
-
-        Request
-                This element is present only if the Request ResponseGroup
-                is specified.
-        Assignment
-                The assignment. The response includes one Assignment object.
-        HIT
-                The HIT associated with this assignment. The response
-                includes one HIT object.
-
-        """
-
-        params = {'AssignmentId': assignment_id}
-
-        # Handle optional response groups argument
-        if response_groups:
-            self.build_list_params(params, response_groups, 'ResponseGroup')
-
-        return self._process_request('GetAssignment', params,
-                                     [('Assignment', Assignment),
-                                      ('HIT', HIT)])
-
-    def get_assignments(self, hit_id, status=None,
-                            sort_by='SubmitTime', sort_direction='Ascending',
-                            page_size=10, page_number=1, response_groups=None):
-        """
-        Retrieves completed assignments for a HIT.
-        Use this operation to retrieve the results for a HIT.
-
-        The returned ResultSet will have the following attributes:
-
-        NumResults
-                The number of assignments on the page in the filtered results
-                list, equivalent to the number of assignments being returned
-                by this call.
-                A non-negative integer
-        PageNumber
-                The number of the page in the filtered results list being
-                returned.
-                A positive integer
-        TotalNumResults
-                The total number of HITs in the filtered results list based
-                on this call.
-                A non-negative integer
-
-        The ResultSet will contain zero or more Assignment objects
-
-        """
-        params = {'HITId': hit_id,
-                  'SortProperty': sort_by,
-                  'SortDirection': sort_direction,
-                  'PageSize': page_size,
-                  'PageNumber': page_number}
-
-        if status is not None:
-            params['AssignmentStatus'] = status
-
-        # Handle optional response groups argument
-        if response_groups:
-            self.build_list_params(params, response_groups, 'ResponseGroup')
-
-        return self._process_request('GetAssignmentsForHIT', params,
-                                     [('Assignment', Assignment)])
-
-    def approve_assignment(self, assignment_id, feedback=None):
-        """
-        """
-        params = {'AssignmentId': assignment_id}
-        if feedback:
-            params['RequesterFeedback'] = feedback
-        return self._process_request('ApproveAssignment', params)
-
-    def reject_assignment(self, assignment_id, feedback=None):
-        """
-        """
-        params = {'AssignmentId': assignment_id}
-        if feedback:
-            params['RequesterFeedback'] = feedback
-        return self._process_request('RejectAssignment', params)
-
-    def approve_rejected_assignment(self, assignment_id, feedback=None):
-        """
-        """
-        params = {'AssignmentId': assignment_id}
-        if feedback:
-            params['RequesterFeedback'] = feedback
-        return self._process_request('ApproveRejectedAssignment', params)
-
-    def get_hit(self, hit_id, response_groups=None):
-        """
-        """
-        params = {'HITId': hit_id}
-        # Handle optional response groups argument
-        if response_groups:
-            self.build_list_params(params, response_groups, 'ResponseGroup')
-
-        return self._process_request('GetHIT', params, [('HIT', HIT)])
-
-    def set_reviewing(self, hit_id, revert=None):
-        """
-        Update a HIT with a status of Reviewable to have a status of Reviewing,
-        or reverts a Reviewing HIT back to the Reviewable status.
-
-        Only HITs with a status of Reviewable can be updated with a status of
-        Reviewing.  Similarly, only Reviewing HITs can be reverted back to a
-        status of Reviewable.
-        """
-        params = {'HITId': hit_id}
-        if revert:
-            params['Revert'] = revert
-        return self._process_request('SetHITAsReviewing', params)
-
-    def disable_hit(self, hit_id, response_groups=None):
-        """
-        Remove a HIT from the Mechanical Turk marketplace, approves all
-        submitted assignments that have not already been approved or rejected,
-        and disposes of the HIT and all assignment data.
-
-        Assignments for the HIT that have already been submitted, but not yet
-        approved or rejected, will be automatically approved. Assignments in
-        progress at the time of the call to DisableHIT will be approved once
-        the assignments are submitted. You will be charged for approval of
-        these assignments.  DisableHIT completely disposes of the HIT and
-        all submitted assignment data. Assignment results data cannot be
-        retrieved for a HIT that has been disposed.
-
-        It is not possible to re-enable a HIT once it has been disabled.
-        To make the work from a disabled HIT available again, create a new HIT.
-        """
-        params = {'HITId': hit_id}
-        # Handle optional response groups argument
-        if response_groups:
-            self.build_list_params(params, response_groups, 'ResponseGroup')
-
-        return self._process_request('DisableHIT', params)
-
-    def dispose_hit(self, hit_id):
-        """
-        Dispose of a HIT that is no longer needed.
-
-        Only HITs in the "reviewable" state, with all submitted
-        assignments approved or rejected, can be disposed. A Requester
-        can call GetReviewableHITs to determine which HITs are
-        reviewable, then call GetAssignmentsForHIT to retrieve the
-        assignments.  Disposing of a HIT removes the HIT from the
-        results of a call to GetReviewableHITs.  """
-        params = {'HITId': hit_id}
-        return self._process_request('DisposeHIT', params)
-
-    def expire_hit(self, hit_id):
-
-        """
-        Expire a HIT that is no longer needed.
-
-        The effect is identical to the HIT expiring on its own. The
-        HIT no longer appears on the Mechanical Turk web site, and no
-        new Workers are allowed to accept the HIT. Workers who have
-        accepted the HIT prior to expiration are allowed to complete
-        it or return it, or allow the assignment duration to elapse
-        (abandon the HIT). Once all remaining assignments have been
-        submitted, the expired HIT becomes"reviewable", and will be
-        returned by a call to GetReviewableHITs.
-        """
-        params = {'HITId': hit_id}
-        return self._process_request('ForceExpireHIT', params)
-
-    def extend_hit(self, hit_id, assignments_increment=None,
-                   expiration_increment=None):
-        """
-        Increase the maximum number of assignments, or extend the
-        expiration date, of an existing HIT.
-
-        NOTE: If a HIT has a status of Reviewable and the HIT is
-        extended to make it Available, the HIT will not be returned by
-        GetReviewableHITs, and its submitted assignments will not be
-        returned by GetAssignmentsForHIT, until the HIT is Reviewable
-        again.  Assignment auto-approval will still happen on its
-        original schedule, even if the HIT has been extended. Be sure
-        to retrieve and approve (or reject) submitted assignments
-        before extending the HIT, if so desired.
-        """
-        # must provide assignment *or* expiration increment
-        if (assignments_increment is None and expiration_increment is None) or \
-           (assignments_increment is not None and expiration_increment is not None):
-            raise ValueError("Must specify either assignments_increment or expiration_increment, but not both")
-
-        params = {'HITId': hit_id}
-        if assignments_increment:
-            params['MaxAssignmentsIncrement'] = assignments_increment
-        if expiration_increment:
-            params['ExpirationIncrementInSeconds'] = expiration_increment
-
-        return self._process_request('ExtendHIT', params)
-
-    def get_help(self, about, help_type='Operation'):
-        """
-        Return information about the Mechanical Turk Service
-        operations and response group NOTE - this is basically useless
-        as it just returns the URL of the documentation
-
-        help_type: either 'Operation' or 'ResponseGroup'
-        """
-        params = {'About': about, 'HelpType': help_type}
-        return self._process_request('Help', params)
-
-    def grant_bonus(self, worker_id, assignment_id, bonus_price, reason):
-        """
-        Issues a payment of money from your account to a Worker.  To
-        be eligible for a bonus, the Worker must have submitted
-        results for one of your HITs, and have had those results
-        approved or rejected. This payment happens separately from the
-        reward you pay to the Worker when you approve the Worker's
-        assignment.  The Bonus must be passed in as an instance of the
-        Price object.
-        """
-        params = bonus_price.get_as_params('BonusAmount', 1)
-        params['WorkerId'] = worker_id
-        params['AssignmentId'] = assignment_id
-        params['Reason'] = reason
-
-        return self._process_request('GrantBonus', params)
-
-    def block_worker(self, worker_id, reason):
-        """
-        Block a worker from working on my tasks.
-        """
-        params = {'WorkerId': worker_id, 'Reason': reason}
-
-        return self._process_request('BlockWorker', params)
-
-    def unblock_worker(self, worker_id, reason):
-        """
-        Unblock a worker from working on my tasks.
-        """
-        params = {'WorkerId': worker_id, 'Reason': reason}
-
-        return self._process_request('UnblockWorker', params)
-
-    def notify_workers(self, worker_ids, subject, message_text):
-        """
-        Send a text message to workers.
-        """
-        params = {'Subject': subject,
-                  'MessageText': message_text}
-        self.build_list_params(params, worker_ids, 'WorkerId')
-
-        return self._process_request('NotifyWorkers', params)
-
-    def create_qualification_type(self,
-                                  name,
-                                  description,
-                                  status,
-                                  keywords=None,
-                                  retry_delay=None,
-                                  test=None,
-                                  answer_key=None,
-                                  answer_key_xml=None,
-                                  test_duration=None,
-                                  auto_granted=False,
-                                  auto_granted_value=1):
-        """
-        Create a new Qualification Type.
-
-        name: This will be visible to workers and must be unique for a
-           given requester.
-
-        description: description shown to workers.  Max 2000 characters.
-
-        status: 'Active' or 'Inactive'
-
-        keywords: list of keyword strings or comma separated string.
-           Max length of 1000 characters when concatenated with commas.
-
-        retry_delay: number of seconds after requesting a
-           qualification the worker must wait before they can ask again.
-           If not specified, workers can only request this qualification
-           once.
-
-        test: a QuestionForm
-
-        answer_key: an XML string of your answer key, for automatically
-           scored qualification tests.
-           (Consider implementing an AnswerKey class for this to support.)
-
-        test_duration: the number of seconds a worker has to complete the test.
-
-        auto_granted: if True, requests for the Qualification are granted
-           immediately.  Can't coexist with a test.
-
-        auto_granted_value: auto_granted qualifications are given this value.
-
-        """
-
-        params = {'Name': name,
-                  'Description': description,
-                  'QualificationTypeStatus': status,
-                  }
-        if retry_delay is not None:
-            params['RetryDelayInSeconds'] = retry_delay
-
-        if test is not None:
-            assert(isinstance(test, QuestionForm))
-            assert(test_duration is not None)
-            params['Test'] = test.get_as_xml()
-
-        if test_duration is not None:
-            params['TestDurationInSeconds'] = test_duration
-
-        if answer_key is not None:
-            if isinstance(answer_key, basestring):
-                params['AnswerKey'] = answer_key  # xml
-            else:
-                raise TypeError
-                # Eventually someone will write an AnswerKey class.
-
-        if auto_granted:
-            assert(test is None)
-            params['AutoGranted'] = True
-            params['AutoGrantedValue'] = auto_granted_value
-
-        if keywords:
-            params['Keywords'] = self.get_keywords_as_string(keywords)
-
-        return self._process_request('CreateQualificationType', params,
-                                     [('QualificationType',
-                                       QualificationType)])
-
-    def get_qualification_type(self, qualification_type_id):
-        params = {'QualificationTypeId': qualification_type_id }
-        return self._process_request('GetQualificationType', params,
-                                     [('QualificationType', QualificationType)])
-
-    def get_all_qualifications_for_qual_type(self, qualification_type_id):
-        page_size = 100
-        search_qual = self.get_qualifications_for_qualification_type(qualification_type_id)
-        total_records = int(search_qual.TotalNumResults)
-        get_page_quals = lambda page: self.get_qualifications_for_qualification_type(qualification_type_id = qualification_type_id, page_size=page_size, page_number = page)
-        page_nums = self._get_pages(page_size, total_records)
-        qual_sets = itertools.imap(get_page_quals, page_nums)
-        return itertools.chain.from_iterable(qual_sets)
-
-    def get_qualifications_for_qualification_type(self, qualification_type_id, page_size=100, page_number = 1):
-        params = {'QualificationTypeId': qualification_type_id,
-                  'PageSize': page_size,
-                  'PageNumber': page_number}
-        return self._process_request('GetQualificationsForQualificationType', params,
-                                     [('Qualification', Qualification)])
-
-    def update_qualification_type(self, qualification_type_id,
-                                  description=None,
-                                  status=None,
-                                  retry_delay=None,
-                                  test=None,
-                                  answer_key=None,
-                                  test_duration=None,
-                                  auto_granted=None,
-                                  auto_granted_value=None):
-
-        params = {'QualificationTypeId': qualification_type_id}
-
-        if description is not None:
-            params['Description'] = description
-
-        if status is not None:
-            params['QualificationTypeStatus'] = status
-
-        if retry_delay is not None:
-            params['RetryDelayInSeconds'] = retry_delay
-
-        if test is not None:
-            assert(isinstance(test, QuestionForm))
-            params['Test'] = test.get_as_xml()
-
-        if test_duration is not None:
-            params['TestDurationInSeconds'] = test_duration
-
-        if answer_key is not None:
-            if isinstance(answer_key, basestring):
-                params['AnswerKey'] = answer_key  # xml
-            else:
-                raise TypeError
-                # Eventually someone will write an AnswerKey class.
-
-        if auto_granted is not None:
-            params['AutoGranted'] = auto_granted
-
-        if auto_granted_value is not None:
-            params['AutoGrantedValue'] = auto_granted_value
-
-        return self._process_request('UpdateQualificationType', params,
-                                     [('QualificationType', QualificationType)])
-
-    def dispose_qualification_type(self, qualification_type_id):
-        """TODO: Document."""
-        params = {'QualificationTypeId': qualification_type_id}
-        return self._process_request('DisposeQualificationType', params)
-
-    def search_qualification_types(self, query=None, sort_by='Name',
-                                   sort_direction='Ascending', page_size=10,
-                                   page_number=1, must_be_requestable=True,
-                                   must_be_owned_by_caller=True):
-        """TODO: Document."""
-        params = {'Query': query,
-                  'SortProperty': sort_by,
-                  'SortDirection': sort_direction,
-                  'PageSize': page_size,
-                  'PageNumber': page_number,
-                  'MustBeRequestable': must_be_requestable,
-                  'MustBeOwnedByCaller': must_be_owned_by_caller}
-        return self._process_request('SearchQualificationTypes', params,
-                    [('QualificationType', QualificationType)])
-
-    def get_qualification_requests(self, qualification_type_id,
-                                   sort_by='Expiration',
-                                   sort_direction='Ascending', page_size=10,
-                                   page_number=1):
-        """TODO: Document."""
-        params = {'QualificationTypeId': qualification_type_id,
-                  'SortProperty': sort_by,
-                  'SortDirection': sort_direction,
-                  'PageSize': page_size,
-                  'PageNumber': page_number}
-        return self._process_request('GetQualificationRequests', params,
-                    [('QualificationRequest', QualificationRequest)])
-
-    def grant_qualification(self, qualification_request_id, integer_value=1):
-        """TODO: Document."""
-        params = {'QualificationRequestId': qualification_request_id,
-                  'IntegerValue': integer_value}
-        return self._process_request('GrantQualification', params)
-
-    def revoke_qualification(self, subject_id, qualification_type_id,
-                             reason=None):
-        """TODO: Document."""
-        params = {'SubjectId': subject_id,
-                  'QualificationTypeId': qualification_type_id,
-                  'Reason': reason}
-        return self._process_request('RevokeQualification', params)
-
-    def assign_qualification(self, qualification_type_id, worker_id,
-                             value=1, send_notification=True):
-        params = {'QualificationTypeId': qualification_type_id,
-                  'WorkerId' : worker_id,
-                  'IntegerValue' : value,
-                  'SendNotification' : send_notification}
-        return self._process_request('AssignQualification', params)
-
-    def get_qualification_score(self, qualification_type_id, worker_id):
-        """TODO: Document."""
-        params = {'QualificationTypeId' : qualification_type_id,
-                  'SubjectId' : worker_id}
-        return self._process_request('GetQualificationScore', params,
-                    [('Qualification', Qualification)])
-
-    def update_qualification_score(self, qualification_type_id, worker_id,
-                                   value):
-        """TODO: Document."""
-        params = {'QualificationTypeId' : qualification_type_id,
-                  'SubjectId' : worker_id,
-                  'IntegerValue' : value}
-        return self._process_request('UpdateQualificationScore', params)
-
-    def _process_request(self, request_type, params, marker_elems=None):
-        """
-        Helper to process the xml response from AWS
-        """
-        params['Operation'] = request_type
-        response = self.make_request(None, params, verb='POST')
-        return self._process_response(response, marker_elems)
-
-    def _process_response(self, response, marker_elems=None):
-        """
-        Helper to process the xml response from AWS
-        """
-        body = response.read()
-        if self.debug == 2:
-            print body
-        if '<Errors>' not in body:
-            rs = ResultSet(marker_elems)
-            h = handler.XmlHandler(rs, self)
-            xml.sax.parseString(body, h)
-            return rs
-        else:
-            raise MTurkRequestError(response.status, response.reason, body)
-
-    @staticmethod
-    def get_keywords_as_string(keywords):
-        """
-        Returns a comma+space-separated string of keywords from either
-        a list or a string
-        """
-        if isinstance(keywords, list):
-            keywords = ', '.join(keywords)
-        if isinstance(keywords, str):
-            final_keywords = keywords
-        elif isinstance(keywords, unicode):
-            final_keywords = keywords.encode('utf-8')
-        elif keywords is None:
-            final_keywords = ""
-        else:
-            raise TypeError("keywords argument must be a string or a list of strings; got a %s" % type(keywords))
-        return final_keywords
-
-    @staticmethod
-    def get_price_as_price(reward):
-        """
-        Returns a Price data structure from either a float or a Price
-        """
-        if isinstance(reward, Price):
-            final_price = reward
-        else:
-            final_price = Price(reward)
-        return final_price
-
-    @staticmethod
-    def duration_as_seconds(duration):
-        if isinstance(duration, datetime.timedelta):
-            duration = duration.days * 86400 + duration.seconds
-        try:
-            duration = int(duration)
-        except TypeError:
-            raise TypeError("Duration must be a timedelta or int-castable, got %s" % type(duration))
-        return duration
-
-
-class BaseAutoResultElement:
-    """
-    Base class to automatically add attributes when parsing XML
-    """
-    def __init__(self, connection):
-        pass
-
-    def startElement(self, name, attrs, connection):
-        return None
-
-    def endElement(self, name, value, connection):
-        setattr(self, name, value)
-
-
-class HIT(BaseAutoResultElement):
-    """
-    Class to extract a HIT structure from a response (used in ResultSet)
-
-    Will have attributes named as per the Developer Guide,
-    e.g. HITId, HITTypeId, CreationTime
-    """
-
-    # property helper to determine if HIT has expired
-    def _has_expired(self):
-        """ Has this HIT expired yet? """
-        expired = False
-        if hasattr(self, 'Expiration'):
-            now = datetime.datetime.utcnow()
-            expiration = datetime.datetime.strptime(self.Expiration, '%Y-%m-%dT%H:%M:%SZ')
-            expired = (now >= expiration)
-        else:
-            raise ValueError("ERROR: Request for expired property, but no Expiration in HIT!")
-        return expired
-
-    # are we there yet?
-    expired = property(_has_expired)
-
-
-class HITTypeId(BaseAutoResultElement):
-    """
-    Class to extract an HITTypeId structure from a response
-    """
-
-    pass
-
-
-class Qualification(BaseAutoResultElement):
-    """
-    Class to extract an Qualification structure from a response (used in
-    ResultSet)
-
-    Will have attributes named as per the Developer Guide such as
-    QualificationTypeId, IntegerValue. Does not seem to contain GrantTime.
-    """
-
-    pass
-
-
-class QualificationType(BaseAutoResultElement):
-    """
-    Class to extract an QualificationType structure from a response (used in
-    ResultSet)
-
-    Will have attributes named as per the Developer Guide,
-    e.g. QualificationTypeId, CreationTime, Name, etc
-    """
-
-    pass
-
-
-class QualificationRequest(BaseAutoResultElement):
-    """
-    Class to extract an QualificationRequest structure from a response (used in
-    ResultSet)
-
-    Will have attributes named as per the Developer Guide,
-    e.g. QualificationRequestId, QualificationTypeId, SubjectId, etc
-    """
-
-    def __init__(self, connection):
-        BaseAutoResultElement.__init__(self, connection)
-        self.answers = []
-
-    def endElement(self, name, value, connection):
-        # the answer consists of embedded XML, so it needs to be parsed independantly
-        if name == 'Answer':
-            answer_rs = ResultSet([('Answer', QuestionFormAnswer)])
-            h = handler.XmlHandler(answer_rs, connection)
-            value = connection.get_utf8_value(value)
-            xml.sax.parseString(value, h)
-            self.answers.append(answer_rs)
-        else:
-            BaseAutoResultElement.endElement(self, name, value, connection)
-
-
-class Assignment(BaseAutoResultElement):
-    """
-    Class to extract an Assignment structure from a response (used in
-    ResultSet)
-
-    Will have attributes named as per the Developer Guide,
-    e.g. AssignmentId, WorkerId, HITId, Answer, etc
-    """
-
-    def __init__(self, connection):
-        BaseAutoResultElement.__init__(self, connection)
-        self.answers = []
-
-    def endElement(self, name, value, connection):
-        # the answer consists of embedded XML, so it needs to be parsed independantly
-        if name == 'Answer':
-            answer_rs = ResultSet([('Answer', QuestionFormAnswer)])
-            h = handler.XmlHandler(answer_rs, connection)
-            value = connection.get_utf8_value(value)
-            xml.sax.parseString(value, h)
-            self.answers.append(answer_rs)
-        else:
-            BaseAutoResultElement.endElement(self, name, value, connection)
-
-
-class QuestionFormAnswer(BaseAutoResultElement):
-    """
-    Class to extract Answers from inside the embedded XML
-    QuestionFormAnswers element inside the Answer element which is
-    part of the Assignment and QualificationRequest structures
-
-    A QuestionFormAnswers element contains an Answer element for each
-    question in the HIT or Qualification test for which the Worker
-    provided an answer. Each Answer contains a QuestionIdentifier
-    element whose value corresponds to the QuestionIdentifier of a
-    Question in the QuestionForm. See the QuestionForm data structure
-    for more information about questions and answer specifications.
-
-    If the question expects a free-text answer, the Answer element
-    contains a FreeText element. This element contains the Worker's
-    answer
-
-    *NOTE* - currently really only supports free-text and selection answers
-    """
-
-    def __init__(self, connection):
-        BaseAutoResultElement.__init__(self, connection)
-        self.fields = []
-        self.qid = None
-
-    def endElement(self, name, value, connection):
-        if name == 'QuestionIdentifier':
-            self.qid = value
-        elif name in ['FreeText', 'SelectionIdentifier', 'OtherSelectionText'] and self.qid:
-            self.fields.append(value)