Request the featureType from the endpoint.
331213
def fetch_feature_type(self):
        """"""
        query = self.query().add_query_parameter(req='featureType')
        return self.get_query(query).content
162351
def get_service(self, service_type=None):
        """"""
        for service in self._services:
            if service.type == service_type and service_type:
                return service
        return None
820640
protected Features getFeaturesFromRequest(HttpServletRequest request, boolean versionError) throws IOException {
		final String sourceMethod = "getFeaturesFromRequest"; //$NON-NLS-1$
		boolean isTraceLogging = log.isLoggable(Level.FINER);
		if (isTraceLogging) {
			log.entering(sourceClass, sourceMethod, new Object[]{request, versionError});
		}
		StringBuffer sb = request.getRequestURL();
		if (sb != null && request.getQueryString() != null) {
			sb.append("?").append(request.getQueryString()); //$NON-NLS-1$
		}
		Features defaultFeatures = getAggregator().getConfig().getDefaultFeatures(sb != null ? sb.toString() : null);
		Features features = null;
		if (!versionError) {		// don't trust feature encoding if version changed
			features = getFeaturesFromRequestEncoded(request, defaultFeatures);
		}
		if (features == null) {
			features = new Features(defaultFeatures);
			String has  = getHasConditionsFromRequest(request);
			if (has != null) {
				for (String s : has.split("[;,*]")) { //$NON-NLS-1$
					boolean value = true;
					if (s.startsWith("!")) { //$NON-NLS-1$
						s = s.substring(1);
						value = false;
					}
					features.put(s, value);
				}
			}
		}
		if (isTraceLogging) {
			log.exiting(sourceClass, sourceMethod, features);
		}
		return features.unmodifiableFeatures();
	}
841470
def _get_valid_endpoint(resp, name, entry_type):
        
        catalog = resp.get('token', {}).get('catalog', [])
        for entry in catalog:
            if (
                entry.get('name')
                and entry.get('type')
                and entry.get('name') == name
                and entry.get('type') == entry_type
            ):
                # Collect any endpoints on the public or internal interface
                valid_endpoints = {}
                for ep in entry.get('endpoints'):
                    interface = ep.get('interface', '')
                    if interface in ['public', 'internal']:
                        valid_endpoints[interface] = ep.get('url')

                if valid_endpoints:
                    # Favor public endpoints over internal
                    return valid_endpoints.get('public', valid_endpoints.get('internal'))

        return None
828217
def get_feature(self, feature_id):
        
        route_values = {}
        if feature_id is not None:
            route_values['featureId'] = self._serialize.url('feature_id', feature_id, 'str')
        response = self._send(http_method='GET',
                              location_id='c4209f25-7a27-41dd-9f04-06080c7b6afd',
                              version='5.0-preview.1',
                              route_values=route_values)
        return self._deserialize('ContributedFeature', response)
527452
def __NeedRequestType(self, method_description, request_type):
        """"""
        if not request_type:
            return True
        method_id = method_description.get('id', '')
        if method_id in self.__unelidable_request_methods:
            return True
        message = self.__message_registry.LookupDescriptorOrDie(request_type)
        if message is None:
            return True
        field_names = [x.name for x in message.fields]
        parameters = method_description.get('parameters', {})
        for param_name, param_info in parameters.items():
            if (param_info.get('location') != 'path' or
                    self.__names.CleanName(param_name) not in field_names):
                break
        else:
            return False
        return True
266467
public static void get(HttpConsumer<HttpExchange> endpoint, MediaTypes... mediaTypes) {
        addResource(Methods.GET, HandlerUtil.BASE_PATH, endpoint, mediaTypes);
    }
484621
def get(self, endpoint, *args, **kwargs):
        
        endpoint = self.base_url + endpoint
        return self._make_request(endpoint, type='GET')
440747
async def get(self, zone_id: int, *, details: bool = False) -> dict:
        """"""
        endpoint = 'zone/{0}'.format(zone_id)
        if details:
            endpoint += '/properties'
        return await self._request('get', endpoint)
207387
def type(self):
        """"""
        if self is FeatureType.TIMESTAMP:
            return list
        if self is FeatureType.BBOX:
            return BBox
        return dict
680868
def handleHttpPost(request, endpoint):
    
    if request.mimetype and request.mimetype != MIMETYPE:
        raise exceptions.UnsupportedMediaTypeException()
    request = request.get_data()
    if request == '' or request is None:
        request = '{}'
    responseStr = endpoint(request)
    return getFlaskResponse(responseStr)
1218196
def _get_acceptable_response_type():
    """"""
    if ('Accept' not in request.headers or request.headers['Accept'] in
            ALL_CONTENT_TYPES):
        return JSON
    acceptable_content_types = set(
        request.headers['ACCEPT'].strip().split(','))
    if acceptable_content_types & HTML_CONTENT_TYPES:
        return HTML
    elif acceptable_content_types & JSON_CONTENT_TYPES:
        return JSON
    else:
        # HTTP 406 Not Acceptable
        raise InvalidAPIUsage(406)
247379
def document_endpoint(endpoint):
    """"""
    descr = clean_description(py_doc_trim(endpoint.__doc__))
    docs = {
        'name': endpoint._route_name,
        'http_method': endpoint._http_method,
        'uri': endpoint._uri,
        'description': descr,
        'arguments': extract_endpoint_arguments(endpoint),
        'returns': format_endpoint_returns_doc(endpoint),
    }
    if hasattr(endpoint, "_success"):
        docs["success"] = endpoint._success
    if hasattr(endpoint, "_requires_permission"):
        docs["requires_permission"] = endpoint._requires_permission
    return docs
987356
def type(self):
        """"""
        return ffi.string(lib.EnvGetDefmessageHandlerType(
            self._env, self._cls, self._idx)).decode()
183989
private static ServiceType serviceTypeFor(final CouchbaseRequest request) {
        if (request instanceof BinaryRequest) {
            return ServiceType.BINARY;
        } else if (request instanceof ConfigRequest) {
            return ServiceType.CONFIG;
        } else if (request instanceof ViewRequest) {
            return ServiceType.VIEW;
        } else if (request instanceof QueryRequest) {
            return ServiceType.QUERY;
        } else if (request instanceof SearchRequest) {
            return ServiceType.SEARCH;
        } else if (request instanceof AnalyticsRequest) {
            return ServiceType.ANALYTICS;
        } else {
            throw new IllegalStateException("Unknown Request: " + request);
        }
    }
595349
def request_type(self):
        """"""
        if self.static and not self.uses_request:
            return getattr(xenon_pb2, 'Empty')

        if not self.uses_request:
            return None

        return getattr(xenon_pb2, self.request_name)
768300
def get(self, data_type, options=None):
        
        if options is None:
            options = {}
        response = self._client.session.get(
            '{url}/{type}'.format(
                url=self.endpoint_url, type=data_type
            ),
            params=options
        )
        return self.process_response(response)