Returns a mapped object from an HTTP resource.
322919
def _get_resource(self, resource, obj, params=None, **kwargs):
        """"""
        r = self._http_resource('GET', resource, params=params)
        item = self._resource_deserialize(r.content.decode("utf-8"))

        return obj.new_from_dict(item, h=self, **kwargs)
602604
def get_obj(ref):
    """"""
    oid = int(ref)
    return server.id2ref.get(oid) or server.id2obj[oid]
529237
def map(self, mapper: Callable[[Any], Any]) -> 'Observable':
        
        """
        source = self
        return Observable(lambda on_next: source.subscribe(compose(on_next, mapper)))
297382
def get_object(request, pid):
    """"""
    sciobj = d1_gmn.app.models.ScienceObject.objects.get(pid__did=pid)
    content_type_str = d1_gmn.app.object_format_cache.get_content_type(
        sciobj.format.format
    )
    # Return local or proxied SciObj bytes
    response = django.http.StreamingHttpResponse(
        _get_sciobj_iter(sciobj), content_type_str
    )
    d1_gmn.app.views.headers.add_sciobj_properties_headers_to_response(response, sciobj)
    d1_gmn.app.event_log.log_read_event(pid, request)
    return response
767253
def _get(self, url, query=None):
        

        if query is None:
            query = {}

        response = retry_request(self)(self._http_get)(url, query=query)

        if self.raw_mode:
            return response

        if response.status_code != 200:
            error = get_error(response)
            if self.raise_errors:
                raise error
            return error

        localized = query.get('locale', '') == '*'
        return ResourceBuilder(
            self.default_locale,
            localized,
            response.json(),
            max_depth=self.max_include_resolution_depth,
            reuse_entries=self.reuse_entries
        ).build()
955262
def get_dict_from_response(response):
    """"""
    result = {}
    if getattr(response, '_resp') and response._resp.code > 400:
        return result

    for i in response.data:
        # strip the schema from the key
        k = i['Type'].replace(REMOTE_APP_RESOURCE_SCHEMA, '')
        result.setdefault(k, list())
        result[k].append(i['Value'])
    return result
972382
def _get(self, uri):
        
        resp, resp_body = self.api.method_get(uri)
        return self.resource_class(self, resp_body, self.response_key,
                loaded=True)
553901
def get_object(self, queryset=None):
        
        obj = User.objects.get(id=self.request.user.id)
        return obj
141630
def _get(self, **kwargs):
        """"""
        path = self._construct_path_to_item()
        return self._http.get(path)
563742
def get(context, resource, **kwargs):
    """"""
    uri = '%s/%s/%s' % (context.dci_cs_api, resource, kwargs.pop('id'))
    r = context.session.get(uri, timeout=HTTP_TIMEOUT, params=kwargs)
    return r
1114415
def _from_api_repr(cls, resource):
        """"""
        job_id = resource.get("jobId")
        project = resource.get("projectId")
        location = resource.get("location")
        job_ref = cls(job_id, project, location)
        return job_ref
442519
def get_object(self, path):
        """"""
        key = self.native_container.get_key(path)
        return self.obj_cls.from_key(self, key)
789819
async def get(self, request, resource=None, **kwargs):
        
        if resource is not None and resource != '':
            return self.to_simple(request, resource, **kwargs)

        return self.to_simple(request, self.collection, many=True, **kwargs)
911563
def get(method, hmc, uri, uri_parms, logon_required):
        """"""
        try:
            metrics_context = hmc.lookup_by_uri(uri)
        except KeyError:
            raise InvalidResourceError(method, uri)
        result = metrics_context.get_metric_values_response()
        return result
997276
private Object resolveHostObject(Object value, Context cx, Scriptable scope) throws Exception {
		if (value instanceof List) { // list -> array
			return RHINO.fromList((List<?>) value, cx, scope);
		}
		if (value instanceof Map) { // map -> object
			return RHINO.fromMap((Map<?, ?>) value, cx, scope);
		}
		if (value instanceof String) {
			String string = (String) value;
			if (string.endsWith(jsSuffix)) { // .js source
				return MODS.create(string, null, scope, cx);
			}
			if (string.endsWith(jsonSuffix)) { // .json structure
				return JsonDeserializer.JSON_DESERIALIZER.deserialize((new URL(string).openStream()));
			}
		}
		return value;
	}
1157077
async def load(self, request, resource=None, **kwargs):
        """"""
        schema = self.get_schema(request, resource=resource, **kwargs)
        data = await self.parse(request)
        resource, errors = schema.load(
            data, partial=resource is not None, many=isinstance(data, list))
        if errors:
            raise RESTBadRequest(reason='Bad request', json={'errors': errors})
        return resource
414267
def get_resource(url, resource_class, params={})
      resource_class.from_hash(get(url, params), client: self)
    end