Gets all assets of a space.
189205
def all(self, query=None, **kwargs):
        

        if query is None:
            query = {}

        normalize_select(query)

        return super(AssetsProxy, self).all(query, **kwargs)
400397
def all(self):
        
        return self._client.get(
            url=self._client.get_full_url(
                self.get_path('collection', realm=self._realm_name)
            )
        )
668010
public function getAssets()
    {
        $assets = [];
        $resources = $this->config()->getItem('meliscore/ressources');
        $useBuildAssets = (bool) $resources['build']['use_build_assets'];

        $cssBuild = $resources['build']['css'];
        $jsBuild = $resources['build']['js'];
        $webpack = file_get_contents($this->getWebPackMixFile());
        $webpackStatic = '';

        if (file_exists($this->getWebPackMixStaticFile())) {
            $webpackStatic = file_get_contents($this->getWebPackMixStaticFile());
        }

        $webpack .= $webpackStatic;

        $scripts = $this->getMergedAssets($useBuildAssets)['js'];
        $stylesheets = $this->getMergedAssets($useBuildAssets)['css'];

        $assets = [
            'css' => $stylesheets,
            'js' => $scripts,
        ];

        $nonBundledCss = $this->getMergedAssets()['css'];
        $nonBundledJs = $this->getMergedAssets()['js'];


        if ($useBuildAssets) {

            $nonBundledJs = array_map(function ($a) {
                // remove the URI query
                $a = str_replace('/', '\/', $a);

                return preg_replace('/\?(.+?)*/', '', $a);
            }, $nonBundledJs);

            $nonBundledCss = array_map(function ($a) {
                // remove the URI query
                $a = str_replace('/', '\/', $a);

                return preg_replace('/\?(.+?)*/', '', $a);
            }, $nonBundledCss);


            // check each file if it has been included in the build assets, if not then stack it
            // to the the assets
            foreach ($nonBundledJs as $key => $script) {
                if (!preg_match("/$script/", $webpack)) {
                    $jsBuild[$script] = $script;
                }
            }

            foreach ($nonBundledCss as $style) {
                if (!preg_match("/$style/", $webpack)) {
                    $cssBuild[$style] = $style;
                }
            }

            $cssBuild = array_map(function ($a) {
                return str_replace('\/', '/', $a);
            }, $cssBuild);

            $jsBuild = array_map(function ($a) {
                return str_replace('\/', '/', $a);
            }, $jsBuild);

        }

        return $assets;
    }
51984
function get_assets(name, extension = 'js')
	{
		let chunk = json.assetsByChunkName[name]

		// a chunk could be a string or an array, so make sure it is an array
		if (!(Array.isArray(chunk)))
		{
			chunk = [chunk]
		}

		return chunk
			// filter by extension
			.filter(name => path.extname(extract_path(name)) === `.${extension}`)
			// adjust the real path (can be http, filesystem)
			.map(name => options.assets_base_url + name)
	}
884548
def get_all(cls, parent=None, **params):

        if parent is not None:
            route = copy(parent.route)
        else:
            route = {}
        if cls.ID_NAME is not None:
            # Empty string triggers "get all resources"
            route[cls.ID_NAME] = ""

        base_obj = cls(key=parent.key, route=route, config=parent.config)
        """"""

        start = datetime.now()
        r = requests.get(
            base_obj._url(), auth=(base_obj.key, ""), params=params)
        cls._delay_for_ratelimits(start)

        if r.status_code not in cls.TRUTHY_CODES:
            return base_obj._handle_request_exception(r)

        response = r.json()
        objects_data = response.get(base_obj.ENVELOPE or base_obj, [])

        return_objects = []
        for data in objects_data:
            # Note that this approach does not get meta data
            return_objects.append(
                cls.get(
                    parent=parent,
                    id=data.get(cls.ID_NAME, data.get("id")),
                    data=data))

        return return_objects
47132
public Map<String, String> getSpaceProperties(String spaceId) {
        Map<String, String> spaceProps = new HashMap<String, String>();
        Map<String, String> allProps = getAllSpaceProperties(spaceId);

        // ONLY include non-ACL properties.
        for (String name : allProps.keySet()) {
            if (!name.startsWith(PROPERTIES_SPACE_ACL)) {
                spaceProps.put(name, allProps.get(name));
            }
        }

        return spaceProps;
    }
716104
def space(self):
        
        schema = SpaceSchema()
        resp = self.service.get(self.base+'space/')
        return self.service.decode(schema, resp)
1296290
def get_all_parcels(self, view = None):
    
    return parcels.get_all_parcels(self._get_resource_root(), self.name, view)
953178
def get_asset(self):
        
        import predix.data.asset
        asset = predix.data.asset.Asset()
        return asset
996734
def extract_assets(dstore, what):
    
    qdict = parse(what)
    dic = {}
    dic1, dic2 = dstore['assetcol/tagcol'].__toh5__()
    dic.update(dic1)
    dic.update(dic2)
    arr = dstore['assetcol/array'].value
    for tag, vals in qdict.items():
        cond = numpy.zeros(len(arr), bool)
        for val in vals:
            tagidx, = numpy.where(dic[tag] == val)
            cond |= arr[tag] == tagidx
        arr = arr[cond]
    return ArrayWrapper(arr, dic)
718559
def get_all(self, qry, tpl):
        '''  '''
        self.cur.execute(qry, tpl)
        result = self.cur.fetchall()
        return result
279124
def get_all(self, search_filter=None):
        """"""
        items = self.backend.get_all()

        if not items:
            if self.version == 1:
                return {self.namespace: []}
            return []

        if search_filter:
            items = jmespath.search(search_filter, items)

        return items
1164108
def _symbols2assets(self, symbols):
        '''
        
        '''

        assets = {a.symbol: a for a in self.get_equities()}
        return [assets[symbol] for symbol in symbols if symbol in assets]
1252409
def items(self):
        """"""
        if self._result_cache:
            return self._result_cache.items

        return self.all().items
597084
public List<Space> getSpaces()
	{
        Builder newQueryBuilder = SpacesQuery.newQuery();
        newQueryBuilder.withSpaceType(SpaceType.GLOBAL);
        SpacesQuery globalSpaceQuery = newQueryBuilder.build();
        return gpUtil.getSpaceManager().getAllSpaces(globalSpaceQuery);
	}
648542
public List<Space> getSpaces(int orgId) {
		return getResourceFactory().getApiResource("/org/" + orgId + "/space/")
				.get(new GenericType<List<Space>>() {
				});
	}
1151708
def all(self, res):
        ""
        B = get_backend()
        return B.get_objects(B.get_concrete(res))