Retrieve a list of collections related to this one.

        :param collection_id [string]: The collection’s ID. Required.
        :return: [Array]: A single page of the Collection list.
346664
def related(self, collection_id):
        
        url = "/collections/%s/related" % collection_id
        result = self._get(url)
        return CollectionModel.parse_list(result)
393164
def list_accounts(self, id, max_id=None, min_id=None, since_id=None, limit=None):
        
        id = self.__unpack_id(id)
        
        if max_id != None:
            max_id = self.__unpack_id(max_id)
        
        if min_id != None:
            min_id = self.__unpack_id(min_id)
        
        if since_id != None:
            since_id = self.__unpack_id(since_id)
        
        params = self.__generate_params(locals(), ['id']) 
        return self.__api_request('GET', '/api/v1/lists/{0}/accounts'.format(id))
1109936
def get_list(self, command, item_class, page_size, page_number, sort_by,
        sort_order, **kwargs):
        
        # pylint: disable=R0913,W0221
        data = self._get_response(command=command,
                                  page_size=page_size,
                                  page_number=page_number,
                                  sort_by=sort_by,
                                  sort_order=sort_order,
                                  video_fields=None,
                                  get_item_count="true",
                                  **kwargs)
        return ItemCollection(data=data,
                              item_class=item_class,
                              _connection=self)
1030967
def get_curated(self, collection_id):
        
        url = "/collections/curated/%s" % collection_id
        result = self._get(url)
        return CollectionModel.parse(result)
998506
def resource_collection_show(self, id, **kwargs):
        ""
        api_path = "/api/v2/resource_collections/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
439599
public function getIndexes($collectionId)
    {
        $urlParams = [self::OPTION_COLLECTION => $collectionId];
        $url       = UrlHelper::appendParamsUrl(Urls::URL_INDEX, $urlParams);
        $response  = $this->getConnection()->get($url);

        return $response->getJson();
    }
447427
def get_collections(self):
        
        collections = []
        for result in self._get_collections():
            collections.append(result['collection'])

        return collections
522249
def get_documents_in_database(self, with_id=True):
        
        documents = []
        for coll in self.get_collection_names():
            documents += self.get_documents_in_collection(
                coll,
                with_id=with_id
            )

        return documents
412939
def get_records(self, ids):
        
        return self.query(Ids(values=[str(id_) for id_ in ids]))
369811
private Set<Scope> getScopeList(ObjectId collectorId) {
        Set<Scope> projects = new HashSet<>();
        if(featureSettings.isCollectorItemOnlyUpdate()){
            for(FeatureBoard featureBoard: enabledFeatureBoards(collectorId)){
                Scope scope = projectRepository.findByCollectorIdAndPId(collectorId, featureBoard.getProjectId());
                if(scope != null){
                    projects.add(scope);
                }
            }
        }else {
            projects = new HashSet<>(projectRepository.findByCollectorId(collectorId));
        }
        return projects;
    }
870391
def get_items(self, collection_uri):
        

        cname = os.path.split(collection_uri)[1]
        return self.search_metadata("collection_name:%s" % cname)
819278
def documents(self):
        

        document_list = []
        document_uri_list = self.api.document.get(collection=self.name)['documents']
        for document_uri in document_uri_list:
            splitted_uri = document_uri.split('/')
            document_key = splitted_uri[-1]
            document_id = "%s/%s" % (self.name, document_key)

            doc = Document(
                id=document_id,
                key=document_key,
                collection=self,
                api=self.api
            )

            document_list.append(doc)

        return document_list
11715
def get(self, request, id):
        
        if id:
            return self._get_one(id)
        else:
            return self._get_all()
817134
def collections(self):
        
        iterator = self._firestore_api.list_collection_ids(
            self._database_string, metadata=self._rpc_metadata
        )
        iterator.client = self
        iterator.item_to_value = _item_to_collection_ref
        return iterator
755008
def get_document(self, document_id):
        
        key = 'doc.%s.%s' % (self.name, decode(document_id))
        return decode_dict(self.db.hgetall(key))
1156467
def getRequest(self, id_):
        
        for request in self.requests:
            if request.id == id_:
                return request

        raise LookupError("Request %r not found" % (id_,))
1265338
def get_collection(self, collection_id):
        """"""
        sql = """SELECT collection.collection_id, collection.type,
                        collection.name, collection.path,
                        collection.doc,
                        collection.version, collection.scope,
                        collection.namedargs,
                        collection.doc_format
                 FROM collection_table as collection
                 WHERE collection_id == ? OR collection.name like ?
        """
        cursor = self._execute(sql, (collection_id, collection_id))
        # need to handle the case where we get more than one result...
        sql_result = cursor.fetchone()
        return {
            "collection_id": sql_result[0],
            "type": sql_result[1],
            "name": sql_result[2],
            "path": sql_result[3],
            "doc":  sql_result[4],
            "version": sql_result[5],
            "scope":   sql_result[6],
            "namedargs": sql_result[7],
            "doc_format": sql_result[8]
        }
        return sql_result