**Arguments**

    ``object_type``
        object type

    :return selected objects
183884
def get_page_objects_by_type(context, object_type):
    
    try:
        objects = context['page']['content'][object_type]
    except KeyError:
        raise template.TemplateSyntaxError('wrong content type: {0:>s}'.format(object_type))
    return objects
895403
def scope_types(self, request, *args, **kwargs):
        
        return response.Response(utils.get_scope_types_mapping().keys())
309572
async def get_object_or_none(cls, db, **kwargs):
        
        async for obj in cls.filter_by(db, limit=1, **kwargs):
            return obj
        return None
364283
def get_selected_object(self):
        
        model, paths = self.tree_view.get_selection().get_selected_rows()
        if len(paths) == 1:
            return self.tree_store.get_iter(paths[0]), paths[0]
        else:
            return None, paths
373251
def get_elements(self, object_list):
        
        result = []
        for item in object_list:
            if isinstance(item, list):
                result += self.get_elements(item)
            elif isinstance(item, TranslatableModel):
                result.append(item)
        return result
751596
def get_object(objref, data=None, return_fields=None, max_results=None,
               ensure_none_or_one_result=False, **api_opts):
    '''
    
    '''
    if not data:
        data = {}
    infoblox = _get_infoblox(**api_opts)
    return infoblox.get_object(objref, data, return_fields,
                               max_results, ensure_none_or_one_result)
1222300
def types(*args, **kwargs):
    

    rtype = first(args)

    return Types(rtype=rtype, ptypes=kwargs)
1270688
def get_items_of_type(self, item_type):
        
        return (item for item in self.items if item.get_type() == item_type)
840323
def get_values(self, dtype=None):
        
        if is_object_dtype(dtype):
            values = self.values.ravel()
            result = self._holder(values).astype(object)
            return result.reshape(self.values.shape)
        return self.values
11110
def _get_members_of_type(obj, member_type):
    

    if not issubclass(type(obj), ModelBase):
        obj = obj.__class__

    key_hash = []
    for key in dir(obj):
        try:
            attr = getattr(obj, key)
        except AttributeError as e:
            try:
                attr = obj.__dict__[key]
            except KeyError:
                raise AttributeError(INTROSPECTION_ERROR % (e, obj, member_type))

        if type(attr) is member_type:
            key_hash.append((key, attr))

    return key_hash
1026378
def get_object(self, item):
        
        if isinstance(item, six.string_types):
            item = self.object_manager.get(item)
        return item
293744
def simxGetObjectSelection(clientID, operationMode):
    '''
    
    '''
    objectCount   = ct.c_int()
    objectHandles = ct.POINTER(ct.c_int)()
    ret = c_GetObjectSelection(clientID, ct.byref(objectHandles), ct.byref(objectCount), operationMode)

    newobj = []
    if ret == 0:
        for i in range(objectCount.value):
            newobj.append(objectHandles[i])

    return ret, newobj
497487
def object(self, session):
        ''''''
        if not hasattr(self, '_object'):
            pkname = self.model_type._meta.pkname()
            query = session.query(self.model_type).filter(**{pkname:
                                                             self.object_id})
            return query.items(callback=self.__set_object)
        else:
            return self._object
587345
def get_object(conn, binding_name, object_cls):
        
        try:
            obj = conn.rootContext.resolve(binding_name)
            narrowed = obj._narrow(object_cls)
        except CORBA.TRANSIENT:
            raise IOError('Attempt to retrieve object failed')

        if narrowed is None:
            raise IOError('Attempt to retrieve object got a different class of object')

        return narrowed
985781
def ensure_object(self, object_type):
        
        rv = self.find_object(object_type)
        if rv is None:
            self.obj = rv = object_type()
        return rv
1122553
function _get_type_by_name(self, document_type) {
	return do_query(self, "SELECT * FROM types WHERE name = $1", [document_type]).then(get_results(NoPg.Type)).then(function(results) {
		debug.assert(results).is('array');
		if(results.length !== 1) {
			if(results.length === 0) {
				throw new TypeError("Database has no type: " + document_type);
			}
			throw new TypeError("Database has multiple types: " + document_type + " (" + results.length + ")");
		}
		var result = results.shift();
		debug.assert(result).is('object');
		return result;
	});
}
168171
def type_handler_object(val, objtype):
    
    handler = handlers.get(objtype)
    if handler:
        return handler().restore(val)
    else:
        return objtype(val)