Fetches the given path in the Graph API.

        We translate args to a valid query string. If post_args is
        given, we send a POST request to the given path with the given
        arguments.
501837
def request(
        self, path, args=None, post_args=None, files=None, method=None
    ):
        
        if args is None:
            args = dict()
        if post_args is not None:
            method = "POST"

        # Add `access_token` to post_args or args if it has not already been
        # included.
        if self.access_token:
            # If post_args exists, we assume that args either does not exists
            # or it does not need `access_token`.
            if post_args and "access_token" not in post_args:
                post_args["access_token"] = self.access_token
            elif "access_token" not in args:
                args["access_token"] = self.access_token

        try:
            response = self.session.request(
                method or "GET",
                FACEBOOK_GRAPH_URL + path,
                timeout=self.timeout,
                params=args,
                data=post_args,
                proxies=self.proxies,
                files=files,
            )
        except requests.HTTPError as e:
            response = json.loads(e.read())
            raise GraphAPIError(response)

        headers = response.headers
        if "json" in headers["content-type"]:
            result = response.json()
        elif "image/" in headers["content-type"]:
            mimetype = headers["content-type"]
            result = {
                "data": response.content,
                "mime-type": mimetype,
                "url": response.url,
            }
        elif "access_token" in parse_qs(response.text):
            query_str = parse_qs(response.text)
            if "access_token" in query_str:
                result = {"access_token": query_str["access_token"][0]}
                if "expires" in query_str:
                    result["expires"] = query_str["expires"][0]
            else:
                raise GraphAPIError(response.json())
        else:
            raise GraphAPIError("Maintype was not text, image, or querystring")

        if result and isinstance(result, dict) and result.get("error"):
            raise GraphAPIError(result)
        return result
182124
def post(self, path, query=None, data=None, redirects=True):
        
        return self.request('POST', path, query, data, redirects)
44005
def get(self, path, params, **options):
        
        return self.request('get', path, params=params, **options)
767395
def get(path, params = nil, headers = {}, auth = true)
      request(path: path, query: params, headers: headers, auth: auth)
    end
406648
def get(self, service, path, **kwargs):
        
        return self.make_request(Methods.GET, service, path, **kwargs)
784590
def post(self, path, **kwargs):
        ''''''
        resp = self._session.post(self._url(path), **self._builder(**kwargs))
        if 'stream' in kwargs:
            return resp
        else:
            return self._resp_error_check(resp)
586491
def get(path, params = {})
      uri = path
      if params.count > 0
        uri += "?#{URI.encode_www_form(params)}"
      end

      headers = {}

      request('GET', uri, nil, headers) do |resp|
        if params[:fetch_all] == true &&
            resp.body.has_key?('pagination') &&
            resp.body['pagination']['next_uri'] != nil
          params[:starting_after] = resp.body['data'].last['id']
          get(path, params) do |page|
            body = resp.body
            body['data'] += page.data
            resp.body = body
            yield(resp) if block_given?
          end
        else
          yield(resp) if block_given?
        end
      end
    end
1292807
def request(self, path, data=None, method='GET'):
        
        url = '%s%s?access_token=%s' % (
            'https://graph.facebook.com',
            path,
            self['oauth_token'])

        req = Request(url, data=data)
        req.get_method = lambda: method

        return loads(urlopen(req).read())
137811
def page_request(path, params={})
      if params[PARAM_PER_PAGE] == NOT_FOUND
        params[PARAM_PER_PAGE] = default_page_size
      end
      if params[PARAM_PAGE] && params[PARAM_PAGE] == NOT_FOUND
        params[PARAM_PAGE] = default_page
      end

      current_api.get_request(path, ParamsHash.new(params))
    end
85336
def post(self, path, data, **options):
        
        data, options = self._update_request(data, options)
        return self.request('post', path, data=data, **options)
72124
def get(self, *args, **kwargs):
        """"""
        if 'convert' in kwargs:
            conversion = kwargs.pop('convert')
        else:
            conversion = True
        kwargs = self._get_keywords(**kwargs)
        url = self._create_path(*args)
        request = self.session.get(url, params=kwargs)
        content = request.content
        self._request = request
        return self.convert(content, conversion)
85298
protected function request($path, array $args = null)
    {
        $url = $this->_url . '/xml' . $path;
        if ($this->getProductId()) {
            $url .= '/productId/' . urlencode($this->getProductId());
        } elseif ($this->getProductCode()) {
            $url .= '/productCode/' . urlencode($this->getProductCode());
        }

        if (self::getRequestAdapter()->hasIp()) {
            if (!empty($args) && empty($args['remoteAddress'])) {
                // not a nested list (for import request)
                if (!is_array(current($args))) {
                    $args['remoteAddress'] = self::getRequestAdapter()->getIp();
                }
            } elseif (count($args) == 1 && !empty($args['remoteAddress'])) {
                $url .= '/remoteAddress/' . urlencode($args['remoteAddress']);
                unset($args['remoteAddress']);
            } else {
                $url .= '/remoteAddress/' . urlencode(self::getRequestAdapter()->getIp());
            }
        }

        return $this->_httpClient->request($url, $this->getUsername(), $this->_getPassword(), $args);
    }
1287098
def fetch(path, payload, id_type, id_number)
      request = unsent_request(path, payload)

      if has_id_info? id_type, id_number
       return request.send(id_type, id_number)
      end

      request
    end
629299
def get(self, path):
        
        data = self.app.test_client().get("/%s" % path).data
        return data
995246
def get(self, path, *args, **kwargs):
        ''''''
        target = self._host.relative(path).utf8
        if not isinstance(target, basestring):
            # on older versions of the `url` library, .utf8 is a method, not a property
            target = target()
        params = kwargs.get('params', {})
        params.update(self._params)
        kwargs['params'] = params
        logger.debug('GET %s with %s, %s', target, args, kwargs)
        return requests.get(target, *args, **kwargs)
1209745
function getUrlParams(path) {
    if (!path) {
      return {};
    }
    var bits = path.split('?');
    var querystring = bits.length > 1 ? bits[1] : '';
    return toObject(querystring);
  }
953109
def post(self, path, data={}):
        ''' '''
        response = requests.post(API_URL + path, data=json.dumps(data), headers=self._set_headers())
        return self._check_response(response, self.post, path, data)