patch a resource
@param  {string} patchURI The URI to be patched
@param  {string} patch    The data to patch
763854
function patch(patchURI, patch, callback) {

  util.patch(patchURI, patch, function(err, res) {
    if (err) {
      callback(err)
    } else {
      callback(null, res)
    }
  })
}
323192
def _patch(self, opt={}):
        
        opt_netloc = opt.pop(Request.opt_url_netloc, None)
        opt_scheme = opt.pop(Request.opt_url_scheme, None)
        if opt_netloc or opt_scheme:
            scheme, netloc, path, params, query, fragment = six.moves.urllib.parse.urlparse(self.__url)
            self.__url = six.moves.urllib.parse.urlunparse((
                opt_scheme or scheme,
                opt_netloc or netloc,
                path,
                params,
                query,
                fragment
            ))

            logger.info('patching url: [{0}]'.format(self.__url))
596431
def patch(self, url, headers=None, body=None, kwargs=None):
        
        return self._request(
            method='patch',
            url=url,
            headers=headers,
            body=body,
            kwargs=kwargs
        )
1132093
func Patch(url string, v ...interface{}) (*Resp, error) {
	return std.Patch(url, v...)
}
529614
function(number, params, headers, callback) {
        var url;
        url = this.client.url() + ("posts/" + (number || ''));
        return this.client.patch(url, params, headers, callback);
      }
1110749
func (rc *RequestConfig) PATCH(path string) *RequestConfig {
	rc.Path = path
	rc.Method = "PATCH"

	return rc
}
190643
def patch(self, urls=None, **overrides):
        """"""
        if urls is not None:
            overrides['urls'] = urls
        return self.where(accept='PATCH', **overrides)
1106122
function update (req, res, next) {
    for (var key in req.body) {
      req.body[key] = utils.toNative(req.body[key])
    }

    var id = utils.toNative(req.params.id)
    var chain = db.get(name)

    chain = req.method === 'PATCH'
      ? chain.updateById(id, req.body)
      : chain.replaceById(id, req.body)

    var resource = chain.value()

    if (resource) {
      res.locals.data = resource
    }

    next()
  }
1226303
func (s *Server) Patch(path string, h HandlerFunc, opts ...HandlerOption) {
	s.register(http.MethodPatch, path, h, opts...)
}
711104
public function patch($uri, array $headers = [], $datas = [], array $files = [])
    {
        return $this->send($uri, InternalRequestInterface::METHOD_PATCH, $headers, $datas, $files);
    }
449589
func (r *Request) Patch(url string) (*Response, error) {
	return r.Execute(MethodPatch, url)
}
560703
public static void patch(String path, String acceptType, Route route) {
        getInstance().patch(path, acceptType, route);
    }
286444
function log(patch) {
		var mw = (patch || core.base());
		mw.enabled = true;
		// let's be gentle
		if (console) {
			mw.writeln = function (str) {
				if (mw.enabled) {
					console.log(String(str));
				}
			};
		}
		else {
			mw.writeln = function (/*str*/) {
				// ignore?
			};
		}
		if (!patch) {
			mw.toString = function () {
				return '<miniwrite-log>';
			};
		}
		return mw;
	}
754611
def _api_model_patch_replace(conn, restApiId, modelName, path, value):
    '''
    
    '''
    response = conn.update_model(restApiId=restApiId, modelName=modelName,
                                 patchOperations=[{'op': 'replace', 'path': path, 'value': value}])
    return response
251945
func (c *Client) Patch() *Request {
	req := c.Request()
	req.Method("PATCH")
	return req
}
265319
def patch(self, url: StrOrURL,
              *, data: Any=None, **kwargs: Any) -> '_RequestContextManager':
        """"""
        return _RequestContextManager(
            self._request(hdrs.METH_PATCH, url,
                          data=data,
                          **kwargs))
328997
public function patch($uri, $body = null, array $options = [])
    {
        return $this->request(self::REQUEST_METHOD_PATCH, $uri, $body, $options);
    }