Get chart

        :returns: a list of :class:`~deezer.resources.Resource` objects.
427671
def get_chart(self, relation=None, index=0, limit=10, **kwargs):
        
        return self.get_object(
            "chart", object_id="0", relation=relation, parent="chart", **kwargs
        )
995018
def resources(self):
        """"""
        return [self.pdf.getPage(i) for i in range(self.pdf.getNumPages())]
608661
def visualizers():
    
    list_of_visualizers = []
    for visualizer in get_visualizations():
        list_of_visualizers.append({'name': visualizer})
    return jsonify(visualizers=list_of_visualizers)
338047
def _retrieve_resources(self, url, class_, full):
        ''''''
        objects_to_return = []
        response = self.session.get(url)
        if response.status_code == 200:
            result = response.json()
            resources = result['results']
            objects_to_return.extend([class_(session=self.session, **resource)
                                      for resource in resources])
            while full and result['next'] is not None:
                response = self.session.get(result['next'])
                if response.status_code == 200:
                    result = response.json()
                    resources = result['results']
                    objects_to_return.extend([class_(session=self.session,
                                                     **resource)
                                              for resource in resources])
                else:
                    raise RuntimeError("Failed downloading data with status {}"
                            ". The response was: '{}'"
                            .format(response.status_code, response.text))
            return objects_to_return
        else:
            raise RuntimeError("Failed downloading data with status {}"
                    ". The response was: '{}'"
                    .format(response.status_code, response.text))
325858
def resources(opts={})
      Tripod::ResourceCollection.new(
        self.resource_class._resources_from_sparql(self.as_query(opts)),
         # pass in the criteria that was used to generate this collection, as well as whether the user specified return graph
        :return_graph => (opts.has_key?(:return_graph) ? opts[:return_graph] : true),
        :criteria => self
      )
    end
1116917
def resources(self):
        """"""
        with open(os.path.join(EULER_DATA, 'resources.json')) as data_file:
            data = json.load(data_file)

        problem_num = str(self.num)

        if problem_num in data:
            files = data[problem_num]

            # Ensure a list of files is returned
            return files if isinstance(files, list) else [files]
        else:
            return None
391417
def get_resources(connection):
    
    resp = connection.describe(verbose=False).split('\r\n')
    resources = [x.replace('a=control:','') for x in resp if (x.find('control:') != -1 and x[-1] != '*' )]
    return resources
1367217
def resources(self):
        
        data = self.query(MyPlexResource.key)
        return [MyPlexResource(self, elem) for elem in data]
55503
def resources(self):
        
        resources = []

        for endpoint in self.endpoints:
            resource_type = endpoint.Meta.resource_type
            table = endpoint.Meta.table
            url = endpoint.name

            resources.append((resource_type, {'table': table, 'url': url}))

        return resources
545311
def urls(self):
        
        urls = []

        for url_name in sorted(self.resources.keys()):

            resource = self.resources[url_name]
            urls.append(resource.as_url(
                api=self,
                name_prefix='-'.join(
                    (self.prefix, self.str_version)).strip('-'),
                url_prefix=self.str_version
            ))

        return patterns(self.prefix, *urls)
1022923
async def get_resources(self, **kwargs) -> dict:
        
        resources = await self.request.get(self._base_path, **kwargs)
        self._sanitize_resources(resources)
        return resources
413128
def get_resources(self):
        
        json_resources = self.rest_client.make_request(self.resource_url)['resources']
        return [RestResource(resource, self.rest_client) for resource in json_resources]
69258
def get_coordinates(self):
        
        resource_list = self.get_resource()
        coordinates = namedtuple('coordinates', ['latitude', 'longitude'])
        try:
            return [coordinates(*resource['point']['coordinates'])
                    for resource in resource_list]
        except (KeyError, TypeError):
            try:
                if isinstance(resource_list, dict):
                    resource_list = [resource_list]
                return [coordinates(resource['Point']['Latitude'],
                                    resource['Point']['Longitude'])
                        for resource in resource_list]
            except (KeyError, ValueError) as exc:
                print(exc)
190807
def resource_list(cls):
        
        items = cls.list()
        ret = [vlan['name'] for vlan in items]
        ret.extend([str(vlan['id']) for vlan in items])
        return ret
751146
def get(self):
        
        resource = dict()
        resource.update(self._parse_config())
        resource.update(self._parse_interfaces())

        return resource
97524
def _get_chart(self, chart_type, x=None, y=None, style=None, opts=None,
				   label=None, options={}, **kwargs):
		
		sbcharts = ["density", "distribution", "dlinear"]
		acharts = ["tick", "circle", "text", "line_num", "bar_num"]
		if chart_type in sbcharts:
			self._set_seaborn_engine()
		if chart_type in acharts:
			self._set_altair_engine()
		if chart_type != "sline":
			x, y = self._check_fields(x, y)
		if opts is None:
			opts = self.chart_opts
		if style is None:
			style = self.chart_style
		if self.engine == "bokeh":
			func = self._get_bokeh_chart
		elif self.engine == "altair":
			func = self._get_altair_chart
		elif self.engine == "chartjs":
			func = self._get_chartjs_chart
		elif self.engine == "seaborn":
			func = self._get_seaborn_chart
		else:
			self.err("Engine " + self.engine + " unknown")
			return
		try:
			chart = func(
				x, y, chart_type, label, opts, style,
				options=options, **kwargs)
			return chart
		except Exception as e:
			self.err(e)
612932
public @NotNull List<Resource> getResources() {
    return getResources((Predicate<Resource>)null, (Resource)null);
  }