Success - all params determined
489471
function(awsParams) {
                        xhr.open("POST", url, true);

                        qq.obj2FormData(awsParams, formData);

                        // AWS requires the file field be named "file".
                        formData.append("file", fileOrBlob);

                        promise.success(formData);
                    }
354162
def on_success(&block)
      on do |_, value, reason|
        block.call(value) unless reason
      end
    end
75761
def save_params(model_name: str):
    """"""
    with open(model_name + '.params', 'w') as f:
        json.dump(pr.__dict__, f)
1329539
def success(self):
        
        return self.ack.upper() in (self.config.ACK_SUCCESS,
                                    self.config.ACK_SUCCESS_WITH_WARNING)
1013617
def param_fetch_all(self):
        ''''''
        if time.time() - getattr(self, 'param_fetch_start', 0) < 2.0:
            # don't fetch too often
            return
        self.param_fetch_start = time.time()
        self.param_fetch_in_progress = True
        self.mav.param_request_list_send(self.target_system, self.target_component)
313424
def get_all_values_of_all_params(self):
        

        values = collections.OrderedDict([[p, []] for p in
                                          sorted(self.get_params())])

        for result in self.get_results():
            for param in self.get_params():
                values[param] += [result['params'][param]]

        sorted_values = collections.OrderedDict([[k,
                                                 sorted(list(set(values[k])))]
                                                 for k in values.keys()])

        for k in sorted_values.keys():
            if sorted_values[k] == []:
                sorted_values[k] = None

        return sorted_values
28062
public function Success ($params = FALSE)
	{
		
		if ($params)
		{
			$this->result	= array_merge ($this->result, $params);
		}
		
		$this->result['status']		= 'ok';
		return TRUE;
	}
850331
def params
      flat = {}
      @options[:params].merge( :track => @options[:filters] ).each do |param, val|
        next if val.to_s.empty? || (val.respond_to?(:empty?) && val.empty?)
        val = val.join(",") if val.respond_to?(:join)
        flat[param.to_s] = val.to_s
      end
      flat
    end
657257
public function successPosAction()
    {
        $response = $this->getRequest()->getParams();
        $result = $this->processPosResponse($response);

        if ($result) {
            $session = $this->_getCheckout();
            $session->unsAdyenRealOrderId();
            $session->setQuoteId($session->getAdyenQuoteId(true));
            $session->getQuote()->setIsActive(false)->save();
            $this->_redirect('checkout/onepage/success', array('utm_nooverride' => '1'));
        } else {
            $this->cancel();
        }
    }
1088001
function(v, o) {
            if (re.test(v)) {
              o[k] = v; // Set params to be returned when matching
              return true;
            } else {
              return false;
            }
          }
1362687
def success(self, request, message, extra_tags='', fail_silently=False):
        """"""
        add(self.target_name, request, constants.SUCCESS, message, extra_tags=extra_tags,
            fail_silently=fail_silently)
1046268
function (params) {
        var self = this;
        this.parseParams(params);
        if (!this.loaded) {
          this.fetchApi(api).success(function (data) {
            packages = data;
            self.loaded = true;
            self.search();
          });
        }
        else {
          this.search();
        }
      }
1262358
def set_params(method, params):
    """"""
    data = {'method': method, 'params': params, 'id': str(uuid4())}
    return json.dumps(data)
211266
function success() {
                self._ws.onclose = function () {
                    if (self._autoReconnect) {
                        var $promise = self.connect(true);
                        self.trigger("close", $promise);
                    } else {
                        self._cleanup();
                        self.trigger("close");
                    }
                };
                deferred.resolve();
            }
1255379
def success(self):
        """"""
        self._check_valid()
        return self._problem._p.get_status() == qsoptex.SolutionStatus.OPTIMAL
1334950
function paramCallback(err) {
    var fn = paramCallbacks[paramIndex++];

    // store updated value
    paramCalled.value = req.params[key.name];

    if (err) {
      // store error
      paramCalled.error = err;
      param(err);
      return;
    }

    if (!fn) return param();

    try {
      fn(req, res, paramCallback, paramVal, key.name);
    } catch (e) {
      paramCallback(e);
    }
  }
1023597
function() {
  var args = Array.from(arguments)
  var url = _.get(args, '[0]', '')
  var params = _.get(args, '[1]', {})

  // if we specify all of the options as a param object, we're basically done
  // and we can skip all of the parameterization checks below
  if (_.isPlainObject(_.get(args, '[0]', {})))
  {
    params = _.get(args, '[0]', {})
  }
   else
  {
    params = _.assign({}, { url }, params)
  }

  return _.assign({}, params, { op: 'request' })
}