Retrieve all reports for parent app

        Returns:
            :class:`list` of :class:`~swimlane.core.resources.report.Report`: List of all returned reports
324203
def list(self):
        
        raw_reports = self._swimlane.request('get', "reports?appId={}".format(self._app.id)).json()
        # Ignore StatsReports for now
        return [Report(self._app, raw_report) for raw_report in raw_reports if raw_report['$type'] == Report._type]
709165
def get_tables(self):
        

        url = self.build_url(self._endpoints.get('get_tables'))
        response = self.session.get(url)

        if not response:
            return []

        data = response.json()

        return [self.table_constructor(parent=self, **{self._cloud_data_key: table})
                for table in data.get('value', [])]
1258434
def parents(self) -> List[str]:
        
        parents = []
        for p in self._c_object.parents:
            parents.append(p.hexsha)
        return parents
667461
def all(self):
        

        response = self._get_json(HTTPMethods.GET, self.saved_query_url, self._get_master_key())

        return response
545710
def ports(self):
        ''''''
        with self._mutex:
            if not self._ports:
                self._ports = [ports.parse_port(port, self) \
                               for port in self._obj.get_ports()]
        return self._ports
177544
def resources(self):
        

        if self._resources_objects is not None:
            return self._resources_objects

        resources = self.parent.parent.resources
        resources = [resources[name] for name in self._resources]
        self._resources_objects = resources
        return resources
923070
def get_reports(self):
        """"""
        return sorted(self._reports,
                      key=lambda x: x['stats']['totalTimeMillis'],
                      reverse=True)
326761
def parents(self):
        # type: () -> List[CommitDetails]
        
        if self._parents is None:
            self._parents = [CommitDetails.get(x) for x in self.parents_sha1]

        return self._parents
1107146
def parents(self):
        
        q = self.__parent__.parents()
        q.put(self)
        return q
1358839
def all(self):
        
        results = self.data[self.data_type]
        while self.current < self.total:
            self.fetch_next_page()
            results.extend(self.data[self.data_type])
        return results
650235
def get_families(self):
        
        if self.retrieved:
            raise errors.IllegalState('List has already been retrieved.')
        self.retrieved = True
        return objects.FamilyList(self._results, runtime=self._runtime)
41963
def get_all_parents(self):
        
        ownership = Ownership.objects.filter(child=self)
        parents = Company.objects.filter(parent__in=ownership)
        for parent in parents:
            parents = parents | parent.get_all_parents()
        return parents
553162
def getall(self):
        

        vrrps = dict()

        # Find the available interfaces
        interfaces = re.findall(r'^interface\s(\S+)', self.config, re.M)

        # Get the vrrps defined for each interface
        for interface in interfaces:
            vrrp = self.get(interface)
            # Only add those interfaces that have vrrps defined
            if vrrp:
                vrrps.update({interface: vrrp})

        return vrrps
474725
def list(self):
        
        response = self._swimlane.request('get', 'app')
        return [App(self._swimlane, item) for item in response.json()]
774415
def all(self):
        
        class_list = list(self.get_class_list())
        if not class_list:
            self.cache = []
            return []

        if self.cache is not None:
            return self.cache

        results = []
        for cls_path in class_list:
            module_name, class_name = cls_path.rsplit('.', 1)
            try:
                module = __import__(module_name, {}, {}, class_name)
                cls = getattr(module, class_name)
                if self.instances:
                    results.append(cls())
                else:
                    results.append(cls)
            except Exception:
                logger.exception('Unable to import {cls}'.format(cls=cls_path))
                continue
        self.cache = results

        return results
712639
def get_worksheets(self):
        

        url = self.build_url(self._endpoints.get('get_worksheets'))
        response = self.session.get(url)

        if not response:
            return []

        data = response.json()

        return [self.worksheet_constructor(parent=self, **{self._cloud_data_key: ws})
                for ws in data.get('value', [])]
855529
def parents(self):
        
        try:
            parents = self.parent.parents
            parents.append(self.parent)
        except AttributeError:
            parents = []
        return parents