Internal: Perform a PATCH request to the Monzo API.

 path - The URI path to request.
 data - The form data to send with the request.
 options - A Hash of query options to include in the URI.

 Returns a HTTP response.
966836
def patch(path, data, options = {})
      uri = build_uri(path, options)

      request = Net::HTTP::Patch.new(uri.request_uri)
      set_authorisation_header(request)
      request.set_form_data(data)

      response = https_client(uri).request(request)
    end
121301
def put(path, data = {}, header = {})
      _send(json_request(Net::HTTP::Patch, path, data, header))
    end
822541
def get(path, params = nil, headers = {})
      response = http_client.get(request_uri(path), params, request_headers(headers))
      if response.status == 200
        parse_response(response)
      else
        handle_error_response(response)
      end
    end
627153
def add_options(self, path: str, handler: _WebHandler,
                    **kwargs: Any) -> AbstractRoute:
        
        return self.add_route(hdrs.METH_OPTIONS, path, handler, **kwargs)
310774
def patch(callback=None, path=None, method=Method.PATCH, resource=None, tags=None, summary="Patch specified resource.",
          middleware=None):
    # type: (Callable, Path, Methods, Resource, Tags, str, List[Any]) -> Operation
    
    def inner(c):
        op = ResourceOperation(c, path or PathParam('{key_field}'), method, resource, tags, summary, middleware,
                               full_clean=False, default_to_not_supplied=True)
        op.responses.add(Response(HTTPStatus.OK, "{name} has been patched."))
        op.responses.add(Response(HTTPStatus.BAD_REQUEST, "Validation failed.", Error))
        op.responses.add(Response(HTTPStatus.NOT_FOUND, "Not found", Error))
        return op
    return inner(callback) if callback else inner
1034375
def options(path, options = {}, &block)
      perform_request Net::HTTP::Options, path, options, &block
    end
1298731
def put_and_get_url(path, options = {})
      ext = options[:ext] || File.extname(path)
      path = path.to_s
      tname = put(path, :ext => ext)

      "http://img0#{rand(4)+1}.taobaocdn.com/tfscom/#{t}#{ext}" unless tname.nil?
    end
550062
public String put(String path, Response data) {
		return request("PUT", path, data, getDefaultOptions());
	}
648180
def get(path, params = nil, headers = {})
      response = http_client.get(
        path: path,
        query: encode_params(params),
        headers: request_headers(headers)
      )
      if response.status == 200
        parse_response(response)
      else
        handle_error_response(response)
      end
    end
1050328
public static function patch($path, $options = array()) {
    $requestOptions = array(
      "path" => $path,
      "method" => "PATCH",
      "body" => $options["body"]
    );

    if (!empty($options["sign"])) {
      $requestOptions["sign"] = $options["sign"];
    }

    return self::request($requestOptions);
  }
44005
def get(self, path, params, **options):
        
        return self.request('get', path, params=params, **options)
1206359
def request(method, path, options = {})
      options = options.dup

      raw = raw? || options.delete(:raw)
      params(options)
      response = connection.send method, path, (@raw_body || @params), @headers
      raw ? response : @scopeable.parse(response)
    end
232630
def put(path, options = {}, headers = {}, raw = false)
      request(:put, path, options, headers, raw)
    end
791600
def get(path, opts = {})
      url = "#{DEFAULT_HOST}/#{path}"
      url += "?#{opts.map {|k, v| "#{k}=#{v}"}.join("&")}" if opts.any?
      uri = URI(url)
      response = http_response(:get, uri)
      JSON.parse(response.body)
    end
1143433
def post(self, path, valuemap=None, query=None):
        
        self.lastpath = path
        if query is not None:
            self.lastpath += '?' + urlencode(query)
        if valuemap:
            self.http.request('POST', self.lastpath, urlencode(valuemap),
                                {"Content-type": "application/x-www-form-urlencoded"})
        else:
            self.http.request('POST', self.lastpath, '')
        resp = self.http.getresponse()
        ctype = resp.getheader('Content-Type')
        data = resp.read().decode('utf-8')
        self.log.debug("Request '%s' status %d, %s length %d", self.lastpath, resp.status, ctype, len(data))
        if resp.status < 400:
            return (resp.status, data, ctype)
        else:
            raise HttpError(code=resp.status, content_type=ctype, content=data)
671135
def request method, path, opts={}
      conn_options = connection_options opts
      opts['api_key'] = api_key unless opts.has_key? 'api_key'
      opts['file_type'] = file_type unless opts.has_key? 'file_type'

      response = connection(conn_options).send(method) do |request|
        case method
        when :get
          request.url path, opts
        when :delete
          request.url path, opts
        when :patch, :post, :put
          if conn_options[:force_urlencoded]
            request.url path, opts
          else
            request.path = path
            request.body = MultiJson.dump(opts) unless opts.empty?
          end
        end
      end

      response
    end
634522
def put(self, path=None, method='PUT', **options):
        
        return self.route(path, method, **options)