We're overriding this to support operation-specific requestion options.
Currently this is for disabling `auth` on specific operations.
15500
public static function defaultCommandFactory(Description $description)
    {
        return function (
            $name,
            array $args = [],
            GuzzleClientInterface $client
        ) use ($description) {

            $operation = null;

            if ($description->hasOperation($name)) {
                $operation = $description->getOperation($name);
            } else {
                $name = ucfirst($name);
                if ($description->hasOperation($name)) {
                    $operation = $description->getOperation($name);
                }
            }

            if (!$operation) {
                return null;
            }

            // this is the only line which is patched
            $args += ($operation->getData('defaults') ?: []);

            return new Command($operation, $args, clone $client->getEmitter());
        };
    }
769815
function yourselfOnly(req, res, next) {
  // Get the username or sessionId from the URL
  var username = req.params.username;
  var sessionId = req.params.sessionId;

  if (!req.session) {
    res.status(401).send('You must be logged-in to access this resource');
  }
  else if (_.contains(req.session.user.roles, 'admin') ||
    (username && req.session.user.username === username) ||
    (sessionId && req.session.id === sessionId)) {
    next();
  }
  else {
    res.status(401).send('You can only perform this operation on your own account');
  }
}
398665
public function hasAuthRequest($operationId = null)
    {
        if (null === $this->authRequestOperations) {
            $this->authRequestOperations = [];
            if (count($this->operations) > 1) {
                foreach ($this->operations as $id => $operation) {
                    if (
                        isset($operation->request)
                        && isset($operation->request->auth)
                        && $operation->request->auth
                    ) {
                        $this->authRequestOperations[$id] = $id;
                    }
                }
            }
        }

        return $operationId ? isset($this->authRequestOperations[$operationId]) : boolval($this->authRequestOperations);
    }
313445
def auth(self, request):
        
        request_token = super(ServiceTumblr, self).auth(request)
        callback_url = self.callback_url(request)

        # URL to redirect user to, to authorize your app
        auth_url_str = '{auth_url}?oauth_token={token}'
        auth_url_str += '&oauth_callback={callback_url}'
        auth_url = auth_url_str.format(auth_url=self.AUTH_URL,
                                       token=request_token['oauth_token'],
                                       callback_url=callback_url)

        return auth_url
395939
async def forget(request):
    
    auth_policy = request.get(POLICY_KEY)
    if auth_policy is None:
        raise RuntimeError('auth_middleware not installed')

    return await auth_policy.forget(request)
846491
def no_auth(self):
        """"""
        old_basic_auth, self.auth = self.auth, None
        old_token_auth = self.headers.pop('Authorization', None)

        yield

        self.auth = old_basic_auth
        if old_token_auth:
            self.headers['Authorization'] = old_token_auth
1328056
function(provider) {
      if (!this.isCurrent()) {
        return;
      }
      if (_.isString(provider)) {
        provider = Parse.User._authProviders[provider];
      }
      if (provider && provider.deauthenticate) {
        provider.deauthenticate();
      }
    }
496520
function () {
    this.log('Deauthorizing...');
    return this.Request.delete('/auth').auth().execute()
      .then(function (response) {
        // Clear auth data from storage upon deauthorization
        this.storage.clear();
        clearAuthData.call(this);

        this.log('Deauthorized and cleared from storage.');

        return response;
      }.bind(this));
  }
861245
def auth_set(self, status):
		
		if not bool(status):
			self.__config['basic_auth'] = None
			self.logger.info('basic authentication has been disabled')
		else:
			self.__config['basic_auth'] = {}
			self.logger.info('basic authentication has been enabled')
958384
def remove_authentication(self, auth_name=None, organization=None):
        
        if auth_name:
            if organization:
                url = '%s/authentications/org/%s/name/%s' % (self.domain, organization, auth_name)
            else:
                url = '%s/authentications/name/%s' % (self.domain, auth_name)
        else:
            url = '%s/authentications' % (self.domain,)

        res = self.session.delete(url)
        self._check_response(res, [201])
69037
private function setRequestOptions()
    {
        $authBearer = 'Bearer '. $this->secretKey;

        $this->client = new Client(
            [
                'base_uri' => $this->baseUrl,
                'headers' => [
                    'Authorization' => $authBearer,
                    'Content-Type'  => 'application/json',
                    'Accept'        => 'application/json'
                ]
            ]
        );
    }
807511
def on_auth_event(ctx, authorization_id, authentication_id, authentication)
      # if authentification is used, override this event
      # and implement your own user management.
      # otherwise all authentifications are blocked per default
      logger.debug("Deny access from #{ctx[:server][:remote_ip]}:#{ctx[:server][:remote_port]} for #{authentication_id}" + (authorization_id == '' ? '' : "/#{authorization_id}") + " with #{authentication}")
      raise Smtpd535Exception
    end
35745
def deauth(self):
        
        self.method = None
        self.key = None
        self.last_auth = None

        if self.debug:
            print("Changing auth key and method to None")

        if self.rfid.authed:
            self.rfid.stop_crypto()
            if self.debug:
                print("Stopping crypto1")
693370
function(webhookId, callback) {
      utils.debug('Webhooks disable: ' + webhookId);
      request.post({
        path: '/webhooks/' + utils.toUUID(webhookId) + '/deactivate',
      }, callback || utils.nop);
    }
1275125
def SetAuth(self, style, user=None, password=None):
        '''
        '''
        self.auth_style, self.auth_user, self.auth_pass = \
            style, user, password
        return self
592163
function(options){
  
  // Set the default options
  this.appKey = '';
  this.environment = 'integration';
  this.redirectUri = '';
  this.tokenCookie = 'FS_AUTH_TOKEN';
  this.maxThrottledRetries = 10;
  this.saveAccessToken = false;
  this.accessToken = '';
  this.jwt = '';
  this.middleware = {
    request: [
      requestMiddleware.url,
      requestMiddleware.defaultAcceptHeader,
      requestMiddleware.authorizationHeader, 
      requestMiddleware.disableAutomaticRedirects, 
      requestMiddleware.body
    ],
    response: [
      responseMiddleware.redirect, 
      responseMiddleware.throttling, 
      responseMiddleware.json
    ]
  };
  
  // Process options
  this.config(options);
}
763459
def require_authentication!(options = {})
      options.reverse_merge!(as: :user)
      return if self.class.allow_actions == :all
      return if self.class.allow_actions.present? && params[:action].to_sym.in?(self.class.allow_actions)

      unless signed_in?(options)
        session["#{options[:as]}_return_to"] = request.url if request.get?
        redirect_to new_session_path_for(options[:as])
      end
    end