Returns the name of the last parameter in a URL rule, eg::

        assert get_last_param_name('/foo/<int:id>/roles') is None

        url_rule = '/foo/<int:id>/bar/<any:something>/baz/<string:spam>'
        assert get_last_param_name(url_rule) == 'spam'
496038
def get_last_param_name(url_rule) -> Union[str, None]:
    
    if not url_rule:
        return None
    match = re.search(LAST_PARAM_NAME_RE, url_rule)
    return match.group('param_name') if match else None
1006353
def parse_fully_qualified_name(fq_name: str) -> Tuple[Optional[str], str]:
    
    last_dot = fq_name.rfind('.')
    if last_dot != -1:
        return fq_name[:last_dot], fq_name[last_dot + 1:]
    else:
        return None, fq_name
641249
def get_parameter(self, name):
        
        name = adapt_name_for_rest(name)
        url = '/mdb/{}/parameters{}'.format(self._instance, name)
        response = self._client.get_proto(url)
        message = mdb_pb2.ParameterInfo()
        message.ParseFromString(response.content)
        return Parameter(message)
438030
def _get_api_params(api_url=None,
                    page_id=None,
                    api_key=None,
                    api_version=None):
    '''
    
    '''
    statuspage_cfg = __salt__['config.get']('statuspage')
    if not statuspage_cfg:
        statuspage_cfg = {}
    return {
        'api_url': api_url or statuspage_cfg.get('api_url') or BASE_URL,  # optional
        'api_page_id': page_id or statuspage_cfg.get('page_id'),  # mandatory
        'api_key': api_key or statuspage_cfg.get('api_key'),  # mandatory
        'api_version': api_version or statuspage_cfg.get('api_version') or DEFAULT_VERSION
    }
1059737
def _get_name_from_url(self, request):
        

        format = request.GET.get('format', None)
        if not format:
            match = self._format_query_pattern.match(request.path)
            if match and match.group('format'):
                format = match.group('format')
        return format
1151556
def get_resource_url(self):
        

        name = self.__class__.resource_name
        url = self.__class__.rest_base_url()

        if self.id is not None:
            return "%s/%s/%s" % (url, name, self.id)

        return "%s/%s" % (url, name)
410129
def _extract_object_params(self, name):
        

        params = self.request.query_params.lists()
        params_map = {}
        prefix = name[:-1]
        offset = len(prefix)
        for name, value in params:
            if name.startswith(prefix):
                if name.endswith('}'):
                    name = name[offset:-1]
                elif name.endswith('}[]'):
                    # strip off trailing []
                    # this fixes an Ember queryparams issue
                    name = name[offset:-3]
                else:
                    # malformed argument like:
                    # filter{foo=bar
                    raise exceptions.ParseError(
                        '"%s" is not a well-formed filter key.' % name
                    )
            else:
                continue
            params_map[name] = value

        return params_map
676948
def get_route_param_names(endpoint):
    """"""
    try:
        g = current_app.url_map.iter_rules(endpoint)
        return next(g).arguments
    except KeyError:
        return {}
571464
public function get_url_params() {
        $args = array(
            'id' => $this->course->id
        );
        if (!empty($this->instancefilter)) {
            $args['ifilter'] = $this->instancefilter;
        }
        if (!empty($this->rolefilter)) {
            $args['role'] = $this->rolefilter;
        }
        if ($this->searchfilter !== '') {
            $args['search'] = $this->searchfilter;
        }
        if (!empty($this->groupfilter)) {
            $args['filtergroup'] = $this->groupfilter;
        }
        if ($this->statusfilter !== -1) {
            $args['status'] = $this->statusfilter;
        }
        return $args;
    }
899649
def get_last_api_metadata(self):
        
        last_metadata = None
        for key, api in iteritems(self.apis):
            api_client = api.api_client
            if api_client is not None:
                metadata = api_client.get_last_metadata()
                if metadata is not None and metadata.get('timestamp', None) is not None:
                    if last_metadata is None:
                        last_metadata = metadata
                    elif metadata["timestamp"] >= last_metadata["timestamp"]:
                        last_metadata = metadata
        if last_metadata is not None:
            last_metadata = ApiMetadata(last_metadata.get("url"),
                                        last_metadata.get("method"),
                                        last_metadata.get("response", None),
                                        last_metadata.get("return_data", None),
                                        last_metadata.get("exception", None))
        return last_metadata
1240200
def get_name_DID_info(self, name, lastblock=None):
        
        if lastblock is None:
            lastblock = self.lastblock

        cur = self.db.cursor()
        did_info = namedb_get_name_DID_info(cur, name, lastblock)
        if did_info is None:
            return None

        return did_info
789505
def get_firewall_rule(self, server_uuid, firewall_rule_position, server_instance=None):
        
        url = '/server/{0}/firewall_rule/{1}'.format(server_uuid, firewall_rule_position)
        res = self.get_request(url)
        return FirewallRule(**res['firewall_rule'])
581693
def last(self, skipna=None, keep_attrs=None):
        
        return self._first_or_last(duck_array_ops.last, skipna, keep_attrs)
823492
def get_url_file_name(url):
        
        url_root_ext = os.path.splitext(url)

        if len(url_root_ext[1]) <= MAX_FILE_EXTENSION_LENGTH:
            return os.path.split(url_root_ext[0])[1]
        else:
            return os.path.split(url)[1]
805545
@Nullable
  private static Node nameOfParam(Node param) {
    switch (param.getToken()) {
      case NAME:
        return param;
      case DEFAULT_VALUE:
        return nameOfParam(param.getFirstChild());
      case REST:
        return nameOfParam(param.getOnlyChild());
      case ARRAY_PATTERN:
      case OBJECT_PATTERN:
        return null;
      default:
        throw new IllegalStateException("Unexpected child of PARAM_LIST: " + param.toStringTree());
    }
  }
40125
String getName() {
        int idx = mName.lastIndexOf('/');
        return (idx > 0) ? mName.substring(idx) : mName;
    }
1259974
private static String getLastPartOfQualifiedName(Node n) {
    if (n.isName()) {
      return n.getString();
    } else if (n.isGetProp()) {
      return n.getLastChild().getString();
    }
    return null;
  }