def create(cls, card_number, cvv, expiry_month, expiry_year, **other_args):
        """
        Creates a payment method.

        Transparent redirects are favored method for creating payment methods.
        Using this call places the burden of PCI compliance on the client since the
        data passes through it.
        ::
            pm = PaymentMethod.create('4242424242424242', '133', '07', '12')
            assert pm.is_sensitive_data_valid
        """
        payload = {
            'payment_method': {
                'card_number': card_number,
                'cvv': cvv,
                'expiry_month': expiry_month,
                'expiry_year': expiry_year,
            }
        }
        optional_data = dict((k, v) for k, v in other_args.iteritems()
                             if k in cls.create_data)
        payload['payment_method'].update(**optional_data)
        payload = dict_to_xml(payload)

        # Send payload and return payment method.
        req = Request(cls.create_url, payload, method='post')
        req.add_header("Content-Type", "application/xml")
        return cls(fetch_url(req))

def download_certificate(order):
    logger = loggers.get_logger(__name__)
    check_credential()
    logger.debug("Downloading certificate")
    # TODO this distinction shouldn't exist here
    if 'certificate' in order and 'id' in order['certificate'] and order['certificate']['id']:  # for cert central accounts
        r = Request(raw_file=True).get('/certificate/{0}/download/format/pem_all'.format(order['certificate']['id']))
    else:  # for mpki/retail accounts
        params = {"format_type": "pem_all"}
        if 'sub_id' in order and order['sub_id']:
            params["sub_id"] = order['sub_id']
        r = Request(raw_file=True).get('/certificate/download/order/{0}'.format(order['id']), params)
    if r.has_error:
        # This is an unrecoverable error. We can't see the API for some reason
        if r.is_response_error():
            logger.error('Server request failed. Unable to access API.')
            sys.exit()
        else:
            logger.error("Server returned an error condition: {0}".format(r.get_message()))
            sys.exit()
    logger.debug("Downloaded certificate for order #{0}".format(order['id']))
    certs = r.data.split("-----BEGIN")  # 0 - empty, 1 - cert, 2 - intermediate, 3 - root... do we need root?
    return {
        "certificate": "-----BEGIN{0}".format(certs[1]),
        "intermediate": "-----BEGIN{0}".format(certs[2]),
        "root": "-----BEGIN{0}".format(certs[3]),
    }

    def update(self, **other_args):
        """
        Updates a payment method.

        Payment method can't be updated once it has been retained or redacted.
        ::
            pm = PaymentMethod.create('4242424242424242', '133', '07', '12')
            assert pm.is_sensitive_data_valid
            pm.update(first_name='dummy')
            if not pm.errors:
                assert pm.first_name == 'dummy'
            else:
                # deal with pm.errors
        """
        payload = {
            'payment_method': {
            }
        }
        optional_data = dict((k, v) for k, v in other_args.iteritems()
                             if k in self.create_data)
        payload['payment_method'].update(**optional_data)
        payload = dict_to_xml(payload)

        # Send payload and return payment method.
        req = Request(self.update_url % self.payment_method_token, payload, method='put')
        req.add_header("Content-Type", "application/xml")
        res = fetch_url(req)
        self._update_fields(res)
        return self

 def __init__(self, attackCard, context):
     """ Initialize the Request with the attack """
     self.attackCard = attackCard
     self.context = context
     self.defenseFilters = [ComparisonFilter(zoneType, FixedCriteria("defendFrom", zoneType, "==")) for zoneType in self.ZONES]
     self.cardsForZone = {}
     Request.__init__(self, [context.player])

 def relationship(to, *args, **kwargs):
     tx = Transaction.get_transaction(kwargs.get("tx", None))
     create_relationship_url = self._dic["create_relationship"]
     data = {
         "to": to.url,
         "type": relationship_name,
     }
     if "tx" in kwargs and isinstance(kwargs["tx"], Transaction):
         x = kwargs.pop("tx", None)
         del x  # Makes pyflakes happy
     if kwargs:
         data.update({"data": kwargs})
     if tx:
         return tx.subscribe(TX_POST, create_relationship_url,
                             data=data, obj=self)
     response, content = Request().post(create_relationship_url,
                                        data=data)
     if response.status == 201:
         return Relationship(response.get("location"))
     elif response.status == 404:
         raise NotFoundError(response.status, "Node specified by the " \
                                              "URI not of \"to\" node" \
                                              "not found")
     else:
         raise StatusException(response.status, "Invalid data sent")

def get_issued_orders(domain_filter=None):
    logger = loggers.get_logger(__name__)
    check_credential()
    filters = '?filters[status]=issued&filters[product_type]=ssl_certificate'
    r = Request().get('/order/certificate{0}'.format(filters))
    if r.has_error:
        # This is an unrecoverable error. We can't see the API for some reason
        if r.is_response_error():
            logger.error('Server request failed. Unable to access API.')
            sys.exit()
        else:
            logger.error("Server returned an error condition: {0}".format(r.get_message()))
            sys.exit()
    order_list = r.data['orders'] if 'orders' in r.data else []
    logger.debug("Collected order list with {0} orders".format(len(order_list)))
    orders = []
    for order in order_list:
        if domain_filter and order['product']['type'] != 'client_certificate':
            if domain_filter in order['certificate']['dns_names']:
                orders.append(order)
            else:   # Check for wildcard matches
                for dns_name in order['certificate']['dns_names']:  # For dns_name *.example.com, the domain_filter ends with .example.com or equals example.com
                    if (dns_name[:2] == '*.') and (dns_name[1:] == domain_filter[1-len(dns_name):] or dns_name[2:] == domain_filter):
                        orders.append(order)
                        break

    logger.debug("Returning {0} orders after filtering".format(len(orders)))
    return orders

 def friend_pages(self):
     '''Get friend's total page numbers
     '''
     self.url.format(self.curpage, self.core_uid)
     http_request = Request(self.url)
     rsp_src = http_request.get_response()
     # Empty rsp_src will raise parse error
     try:
         assert rsp_src
     except AssertionError:
         print("except AssertionError, "
               "http_request.get_response() failed and return nothing, "
               "Check your network and cookie, ",
               file=error_log)
         return
     # Parse the page and get friend's total page numbers
     soup = BeautifulSoup(rsp_src)
     text = str(soup.findAll("a", attrs={"title": unicode("最后页", "utf-8")}))
     pattern = "curpage=[0-9]+"
     r = re.search(pattern, text)
     #
     try:
         result = int(text[r.start() + 8: r.end()])
     except AttributeError:
         with open(r"./error.log", 'a+') as error_log:
             print("except AttributeError, re.search fail:", file=error_log)
             print("soup: ", soup, file=error_log)
             print("pattern: ", pattern, file=error_log)
             print("text: ", text, file=error_log)
             print("r: ", r, '\n', file=error_log)
             return
     return result

    def test_variables(self):
        request_dictionary = {'method': 'get',
                              'name': 'name',
                              'url': '{{urlvar}}',
                              'headers': {
                                  'myheader': '{{headervar}}',
                                  'myheader2': '{{header2var}}',
                              },
                              'params': {
                                  'myparam': '{{paramvar}}'
                              },
                              'body': '{{bodyvar}}'
        }

        request = Request(request_dictionary)

        variable_list = request.get_variable_list()
        self.assertListEqual(['header2var', 'headervar', 'urlvar', 'paramvar', 'bodyvar'],
                             variable_list)

        variables = {'urlvar': 'urlvalue', 'headervar': 'headervalue', 'header2var': 'header2value',
                     'paramvar': 'paramvalue', 'bodyvar': 'bodyvalue'}
        request.substitute_variables(variables)
        self.assertEqual('Request name: name' + os.linesep +
                         '  Method    : get' + os.linesep +
                         '  Headers   : myheader: headervalue, myheader2: header2value' + os.linesep +
                         '  URL       : urlvalue' + os.linesep +
                         '  Parameters: myparam=paramvalue' + os.linesep +
                         '  Body      : bodyvalue',
                         request.__str__())

    def test_constructor(self):
        request_dictionary = {'method': 'get',
                              'name': 'namevalue',
                              'url': 'http://httpbin.org/get',
                              'headers': {
                                  'myheader': 'headervalue',
                                  'myheader2': 'headervalue2',
                              },
                              'params': {
                                  'myparam': 'paramvalue'
                              },
                              'body': 'bodyvalue'
        }

        request = Request(request_dictionary)

        self.assertEqual('get', request.method)
        self.assertEqual('namevalue', request.name)
        self.assertEqual('http://httpbin.org/get', request.url)
        self.assertEqual('headervalue', request.headers['myheader'])
        self.assertEqual('paramvalue', request.params['myparam'])
        self.assertEqual('bodyvalue', request.body)

        self.assertEqual('Request name: namevalue' + os.linesep +
                         '  Method    : get' + os.linesep +
                         '  Headers   : myheader: headervalue, myheader2: headervalue2' + os.linesep +
                         '  URL       : http://httpbin.org/get' + os.linesep +
                         '  Parameters: myparam=paramvalue' + os.linesep +
                         '  Body      : bodyvalue',
                         request.__str__()
        )

    def database(self, name, credentials=ADMIN, create=False, storage='memory'):
        """Sends a request the server for a database
        will both add new and query existing databases.
        
        Returns a Datase object
        """
        if create:
            url = Database.action['post'] % (self.url, name, storage)
            response, content = self.request.post(url=url, data=None)

            if response.status == 200:
                return self.database(name=name, credentials=ADMIN)
            else:
                raise CompassException(content)
        else:
            url = Database.action['get'] % (self.url, name)
            user, password = credentials
            request = Request(user, password)
            response, content = request.get(url=url)

            if response.status == 200:
                data = json.loads(content)
                return Database(self.url, name=name,
                                credentials=credentials, data=data).connect()
            else:
                raise CompassException(content)

 def action(self, rest_path):
     params = {
             'api_key': self.api_key,
             'auth_token': self.auth_token
             }
     req = Request(rest_path, **params)
     req.do()
     return req.result

def main():
    req = Request()
    req.agents = [
        ('Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like '
         'Gecko) Chrome/46.0.2486.0 Safari/537.36 Edge/13.10586'),
        ('Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like '
         'Gecko) Chrome/51.0.2704.103 Safari/537.36')]
    response = req.get('http://utaukitune.ldblog.jp/archives/65696057.html')
    print __parse(response.text)

def main():
    req = Request()
    req.agents = [
        ('Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like '
         'Gecko) Chrome/46.0.2486.0 Safari/537.36 Edge/13.10586'),
        ('Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like '
         'Gecko) Chrome/51.0.2704.103 Safari/537.36')]
    response = req.get(REQ)
    print __parse(response.text)

 def get_account_info(self):
     params = {
             'action': 'get_account_info',
             'api_key': self.api_key,
             'auth_token': self.auth_token
             }
     req = Request('', api_version = 1, params = params)
     req.do()
     return req.result

    def test_run_error_callback(self):
        mock_error_cb = Mock()

        req = Request('http://dummy', error_callback=mock_error_cb)

        mock_resp = ErrorResponse(req, Exception())
        req.run_callback(mock_resp)

        mock_error_cb.assert_called_once_with(mock_resp)

    def test_run_success_callback(self):
        mock_success_cb = Mock()

        req = Request('http://dummy', success_callback=mock_success_cb)

        mock_resp = Response(req, 200, 'content', {})
        req.run_callback(mock_resp)

        mock_success_cb.assert_called_once_with(mock_resp)

def home(request):
    if request.method == 'POST':
        form = TaskForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            request = Request('me','www.baidu.com')
            re = request.start()
            return HttpResponse( re)
    else:
        form = TaskForm()
    return render_to_response('home.html',{'form':form }, RequestContext(request))

    def view_task(self, task_id):
        """Get the details of the task with the given id."""
        api_url = self.server_url + self.METHOD_VIEW_TASK + str(task_id)

        request = Request(api_url)

        log.info("Request to " + api_url)
        try:
            response = request.get()
        except HTTPError, e:
            log.error("Error in view_task: " + str(e))
            raise CuckooError(str(e))

 def authtoken(self):
     if self.authenticated:
         raise TMDBError("Session is already authenticated")
     if self._authtoken is None:
         req = Request('authentication/token/new')
         req.lifetime = 0
         dat = req.readJSON()
         if not dat['success']:
             raise TMDBError("Auth Token request failed")
         self._authtoken = dat['request_token']
         self._authtokenexpiration = datetime.fromIso(dat['expires_at'])
     return self._authtoken

	def describe(self):
		"""
            Returns a description of the vault by requesting it
			from Amazon Glacier
            
			:return: Parsed answer from Amazon Glacier
			:rtype: dictionary
        """
		req = Request(self.connection, self.region, "GET",
		"/-/vaults/"+self.name)
		resp = req.send_request()
		return json.loads(resp.read())