Exact method for getting http_info but with form data work around.
180724
def get_http_info_with_retriever(self, request, retriever):
        
        urlparts = urlparse.urlsplit(request.url)

        try:
            data = retriever(request)
        except Exception:
            data = {}

        return {
            'url': '{0}://{1}{2}'.format(
                urlparts.scheme, urlparts.netloc, urlparts.path),
            'query_string': urlparts.query,
            'method': request.method,
            'data': data,
            'cookies': request.cookies,
            'headers': request.headers,
            'env': {
                'REMOTE_ADDR': request.remote_addr,
            }
        }
1146214
def get_post_data(self, request):
        
        params = dict(request.POST)
        params.update(request.FILES)

        data = defaultdict(dict)

        # Split data and meta parameters
        for param in sorted(params.keys()):
            value = params[param]

            if isinstance(value, list) and len(value) <= 1:
                value = value[0] if value else None

            prefix, _, field = param.partition('[')
            if field:
                field = field[:-1]
                try:
                    data[prefix][field] = value
                except TypeError:
                    raise InvalidNodeData('Got both reserved parameter "data" and plugin specific parameters.')
            else:
                data[prefix] = value

        return data['data'], data['meta']
1317897
def http_method(self, data):
        """"""
        data = data.upper()
        if data in ['DELETE', 'GET', 'POST', 'PUT']:
            self._request.http_method = data
            self._http_method = data
1262717
def get_http_response(self):
        """"""
        return _get_response(
            code=self.code,
            body=str(self),
            headers={
                'Content-Type': 'text/plain'
            }
        )
877367
def info(self, url, limit=None):
        
        return self._limit_get('api', 'info', params=dict(url=url), limit=limit)
932166
def parse_form(self, req, name, field):
        """"""
        return get_value(req.body_arguments, name, field)
123342
def get_submission(submission_id, opts = {})
      data, _status_code, _headers = get_submission_with_http_info(submission_id, opts)
      data
    end
1195074
def get_server_info
      params = MagicParams.format(user_id: @allscripts_username)
      results = magic("GetServerInfo", magic_params: params)
      results["getserverinfoinfo"][0] # infoinfo is an Allscript typo
    end
809140
def info(self, name):
        """"""
        r = requests.get('{}/{}'.format(self.url_service, name))
        return r.json()
927027
def load_info(self):
        '''  '''
        headers = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain",'Referer': 'http://'+self.domain+'/login.phtml',"User-Agent": user_agent}
        req = self.session.get('http://'+self.domain+'/team_news.phtml',headers=headers).content
        soup = BeautifulSoup(req)
        self.title = soup.title.string
        
        estado = soup.find('div',{'id':'content'}).find('div',{'id':'manager'}).string
        if estado:
            print estado.strip()
            return

        [s.extract() for s in soup('strong')]
        if (soup.find('div',{'id':'userid'}) != None):
            self.myid = soup.find('div',{'id':'userid'}).p.text.strip()[2:]
            self.money = int(soup.find('div',{'id':'manager_money'}).p.text.strip().replace(".","")[:-2])
            self.teamvalue = int(soup.find('div',{'id':'teamvalue'}).p.text.strip().replace(".","")[:-2])
            self.community_id = soup.find('link')['href'][24:]
            self.username = soup.find('div',{'id':'username'}).p.a.text
707182
def get(url):
    """"""
    writeln("Getting data from url", url)
    response = requests.get(url)
    if response.status_code == 200:
        writeln(response.text)
    else:
        writeln(str(response.status_code), response.reason)
1115174
function getResults( form, url, callback ){
    var formData = new FormData( form );
    var request = new XMLHttpRequest();
    request.open("POST", url);
    request.send(formData);
    
    request.onload = function(e) {
     if (request.status == 200) {
            callback(null, JSON.parse(request.responseText));
        } else {
            callback("Error " + request.status + ' - ' + request.responseText, null);
        }
    };
}
697983
function pForm (url, form){
    var options = {
        method: 'POST',
        uri: url,
        form: form,
        headers: {
            'content-type': 'application/x-www-form-urlencoded'
        }
    };
    return rp(options);
}
433779
def applies_to(self, url_data):
        """"""
        return url_data.valid and url_data.scheme == 'https' and \
          not url_data.extern[0] and url_data.url_connection is not None
970412
def x_www_form_urlencoded(post_data):
    
    if isinstance(post_data, dict):
        return "&".join([
            u"{}={}".format(key, value)
            for key, value in post_data.items()
        ])
    else:
        return post_data
1241431
def _request(self, function, params, method='POST', headers={}):
        """"""
        
        if method is 'POST':
            params = urllib.parse.urlencode(params)
            headers = { "Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain" }
        
        path = '/%s/%s' % (self._version, function)
        
        self._conn.request(method, path, params, headers)
        return self._conn.getresponse()
145515
def get_data_from_request():
    """"""
    return {
        'request': {
            'url': '%s://%s%s' % (web.ctx['protocol'], web.ctx['host'], web.ctx['path']),
            'query_string': web.ctx.query,
            'method': web.ctx.method,
            'data': web.data(),
            'headers': dict(get_headers(web.ctx.environ)),
            'env': dict(get_environ(web.ctx.environ)),
        }
    }