Returns form data of this post policy setting the provided region.
177093
public Map<String,String> formData(String accessKey, String secretKey, String region)
      throws NoSuchAlgorithmException, InvalidKeyException, InvalidArgumentException {

    if (Strings.isNullOrEmpty(region)) {
      throw new InvalidArgumentException("empty region");
    }

    return makeFormData(accessKey, secretKey, region);
  }
454277
def get_POST_data(self):
        
        self._postprocess()

        # some fields need to be remapped (depends on type of media)
        self._apply_mapping(
            self.mapping.get(self._POST["P0502010__b"], self.mapping["else"])
        )

        self._check_required_fields()

        return self._POST
1025863
function get_submitted_data() {
        $mform =& $this->_form;

        if ($this->is_submitted()) {
            $data = $mform->exportValues();
            unset($data['sesskey']); // we do not need to return sesskey
            unset($data['_qf__'.$this->_formname]);   // we do not need the submission marker too
            if (empty($data)) {
                return NULL;
            } else {
                return (object)$data;
            }
        } else {
            return NULL;
        }
    }
480244
public function getFromForm()
    {
        if ($this->form !== null) {
            $this->user_id = $this->form->user_id;
            $this->phone = $this->form->phone;
            $this->code = $this->form->code;
            $this->type_id = $this->form->type_id;
            $this->ip = $this->form->ip;
            $this->is_used = $this->form->is_used;
            $this->is_validated = $this->form->is_validated;
            $this->is_deleted = $this->form->is_deleted;
        }
    }
1293141
def get_formset(self, request, obj=None, **kwargs):
        
        data = super().get_formset(request, obj, **kwargs)
        if obj:
            data.form.base_fields['user'].initial = request.user.id
        return data
81775
public function get_setting() {
        global $CFG;

        $config = $this->config_read($this->name);
        if (is_null($config)) {
            return null;
        }

        return $this->prepare_form_data($config);
    }
1214601
def get_region(service, region, profile):
    
    _, region, _, _ = _get_profile(service, region, None, None, profile)

    return region
387981
def parse_region(self):
        """"""

        try:
            auth_url = self.job_args['os_auth_url']
            if 'tokens' not in auth_url:
                if not auth_url.endswith('/'):
                    auth_url = '%s/' % auth_url
                auth_url = urlparse.urljoin(auth_url, 'tokens')
            return auth_url
        except KeyError:
            raise exceptions.AuthenticationProblem(
                'You Are required to specify an Auth URL, Region or Plugin'
            )
355546
def get_post_data(self):
        '''
        
        '''
        post_data = {}
        for key in self.request.arguments:
            post_data[key] = self.get_arguments(key)[0]
        return post_data
821507
public function get_data() {
		$data        = array(
			$this->slug => null,
		);
		$submit_data = uix()->request_vars( 'post' );
		$id = $this->id();
		if ( isset( $submit_data[ $id ] ) ) {
			$this->data[ $id ][ $this->slug ] = $submit_data[ $id ];
		}
		if ( isset( $this->data[ $id ] ) ) {
			$data = $this->data[ $id ];
		}

		return $data;
	}
1233900
def get_form_data(defopts, opts)
      # HACK: REG.API doesn't know about utf-8.
      io_encoding = 'utf8'  if !io_encoding || io_encoding == DEFAULT_IO_ENCODING
      opts = opts.to_hash  if opts.respond_to?(:to_hash)
      req_contract = RegApi2::RequestContract.new(defopts)
      opts = req_contract.validate(opts)

      form = {
        'username'          => username || DEFAULT_USERNAME,
        'password'          => password || DEFAULT_PASSWORD,
        'io_encoding'       => io_encoding,
        'lang'              => lang || DEFAULT_LANG,
        'output_format'     => 'json',
        'input_format'      => 'json',
        'show_input_params' => 0,
        'input_data'        => Yajl::Encoder.encode(opts)
      }

      form
    end
216642
protected function getPostedData()
    {
        $resourcePostedDataMode = $this->getResource()->getPostedDataMethod();
        $endpointPostedDataMode = $this->getEndpoint()->getPostedDataMethod();

        $postedDataMode = $resourcePostedDataMode;
        if ($endpointPostedDataMode != PostedDataMethods::AUTO) {
            $postedDataMode = $endpointPostedDataMode;
        }

        $postedData = null;

        switch ($postedDataMode) {

            case PostedDataMethods::POST:
                $postedData = $this->request->getPost();
                break;

            case PostedDataMethods::JSON_BODY:
                $postedData = $this->request->getJsonRawBody(true);
                break;

            case PostedDataMethods::AUTO:
            default:
                $postedData = $this->request->getPostedData($this->getEndpoint()->getHttpMethod());
        }

        return $postedData;
    }
520951
public GetAnyLocationsResponse getAnyLocations(String region) throws ApiException {
        ApiResponse<GetAnyLocationsResponse> resp = getAnyLocationsWithHttpInfo(region);
        return resp.getData();
    }
404930
protected function getInputData()
    {
        (new HCCountriesValidator())->validateForm();

        $_data = request()->all();

        array_set($data, 'languages', array_get($_data, 'languages'));

        return $data;
    }
576689
def get_district_for_section(id, opts = {})
      data, _status_code, _headers = get_district_for_section_with_http_info(id, opts)
      return data
    end
230593
def getPostStates(self):
        '''
        
        '''
        self.aLvlNow = self.mLvlNow - self.cLvlNow - self.MedPriceNow*self.MedNow
        return None
223235
def get_policy(policy_name,
               region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    try:
        ret = conn.get_policy(_get_policy_arn(policy_name,
                            region=region, key=key, keyid=keyid, profile=profile))
        return ret.get('get_policy_response', {}).get('get_policy_result', {})
    except boto.exception.BotoServerError:
        return None