Get resource item
        :param path: string
        :return: Image
504941
def get_item(self, path):
        
        try:
            f = tempfile.NamedTemporaryFile()
            self.blob_service.get_blob_to_path(self.container_name, path, f.name)
            f.seek(0)
            image = Image.open(f.name)
            f.close()

            return image
        except AzureMissingResourceHttpError:
            return False
821056
private Map<String, String> resourceForPath(Path path) {
        return AuthorizationUtil.resource(STORAGE_PATH_AUTH_RES_TYPE, authResForPath(path));
    }
1172210
def get_template(self, path):
        

        if self.options['debug'] and self.options['cache_size']:
            return self.cache.get(path, self.cache_template(path))
        return self.load_template(path)
660616
def get(self, path, data=None, return_fields=None):
        
        return self.session.get(self._request_url(path, return_fields),
                                data=json.dumps(data),
                                auth=self.auth, verify=False)
169408
def get(self, path):
        
        key = tuple(map(id, path))
        item = self._cache.get(key, None)
        if item is None:
            logger.debug("Transform cache miss: %s", key)
            item = [0, self._create(path)]
            self._cache[key] = item
        item[0] = 0  # reset age for this item

        # make sure the chain is up to date
        #tr = item[1]
        #for i, node in enumerate(path[1:]):
        #    if tr.transforms[i] is not node.transform:
        #        tr[i] = node.transform

        return item[1]
115829
def get_contents(self, path, ref=github.GithubObject.NotSet):
        
        return self.get_file_contents(path, ref)
1037483
def GET(self, path):
        
        url = self._absolute_url(path)
        resp = requests.get(url, headers=self.headers, verify=self.verify_ssl)
        if resp.status_code != 200:
            raise MispTransportError('GET %s: returned status=%d', path, resp.status_code)
        return resp.content
1299457
def get(path, options={}, raw=false, unformatted=true)
      request(:get, path, options, raw, unformatted)
    end
123710
def get(self, path, default=None):
        

        try:
            return self.__getitem__(path)
        except KeyError as error:
            return default
704952
def resource_string(self, path):
        
        opener = self.get_opener(path)
        filename = opener.get_filename
        try:
            size = os.path.getsize(filename)
            if size > 50 * 1024 * 1024:
                logger.warning(
                    'Reading large resource to memory: %s. Size: %s bytes',
                    filename, size)
        except Exception as exc:
            logger.debug('Unable to check resource size %s. %s', filename, exc)
        with opener(filename, 'r') as resource:
            content = resource.read()
        return content
647625
@Override
    public URL getResource(final String path) {
        final ResourceList resourceList = scanResult.getResourcesWithPath(path);
        if (resourceList == null || resourceList.isEmpty()) {
            return super.getResource(path);
        } else {
            return resourceList.get(0).getURL();
        }
    }
141630
def _get(self, **kwargs):
        """"""
        path = self._construct_path_to_item()
        return self._http.get(path)
1162012
def metadata_get(self, path, cached=True):
        
        try:
            value = graceful_chain_get(self.inspect(cached=cached).response, *path)
        except docker.errors.NotFound:
            logger.warning("object %s is not available anymore", self)
            raise NotAvailableAnymore()
        return value
1372332
def get(path, params = {})
      headers = request_headers(:get, path, params)
      request(:get, path, params, headers)
    end
362221
def get_response(self, path, **params):
        
        url = "%s%s" % (self.base_url, path)
        return self._get_response(url, **params)
1232084
def get(self, path):
        
        uri = self.config.get_target() + path
        headers = self._get_headers()

        logging.debug("URI=GET " + str(uri))
        logging.debug("HEADERS=" + str(headers))

        response = self.session.get(uri, headers=headers)
        if response.status_code == 200:
            return response.json()
        elif response.status_code == 401:
            raise predix.admin.cf.config.CloudFoundryLoginError('token invalid')
        else:
            response.raise_for_status()
1047854
def get(path)
      tmp = Rudy::Backup.new path
      backups = Rudy::Backups.list :path => path
      return nil unless backups.is_a?(Array) && !backups.empty?
      backups.first
    end