Gets to file infos in a single box.
		Args:
			box_key		key for the file 
			return		(status code, list of file info dicts)
174314
def get_box_files(self, box_key):
		'''
		'''
		uri = '/'.join([self.api_uri,
						self.boxes_suffix,
						box_key,
						self.files_suffix
						])

		return self._req('get', uri)
279385
def get_key_value_pairs(self, subsystem, filename):
        
        assert subsystem in self
        return util.read_key_value_pairs_from_file(self.per_subsystem[subsystem], subsystem + '.' + filename)
446609
def getKey(self, key):
		
		data = self.getDictionary()
		if key in data:
			return data[key]
		else:
			return None
95802
def scan_file(self, filename, apikey):
        
        url = self.base_url + "file/scan"
        params = {'apikey': apikey}
        scanfile = {"file": open(filename, 'rb')}
        response = requests.post(url, files=scanfile, params=params)
        rate_limit_clear = self.rate_limit()
        if rate_limit_clear:
            if response.status_code == self.HTTP_OK:
                json_response = response.json()
                return json_response
            elif response.status_code == self.HTTP_RATE_EXCEEDED:
                time.sleep(20)
            else:
                self.logger.error("sent: %s, HTTP: %d", filename, response.status_code)
150547
def [](key)
      file = filename key
      return unless File.exist? file

      File.read(file, encoding: "utf-8")
    end
206832
def file_info(self, filepath, results: str = 'dict', fileref: str = '_spfinfo', quiet: bool = False):
        

        if not self.nosub:
           code  = "filename "+fileref+" '"+filepath+"';\n"
           code += "%put FILEREF_EXISTS=%sysfunc(fexist("+fileref+"));"
   
           ll = self.submit(code)
   
           exists = ll['LOG'].rpartition('FILEREF_EXISTS=')[2].split('\n')[0]
   
           if exists != '1':
              if not quiet:
                 print('The filepath provided does not exist')
              ll = self.submit("filename "+fileref+" clear;")
              return None

        if results != 'dict':
           code="""
           proc delete data=work._SASPY_FILE_INFO;run;
           data work._SASPY_FILE_INFO;
              length infoname infoval $256;
              drop rc fid infonum i close;
              fid=fopen('filerefx');
              if fid then
                 do;
                    infonum=foptnum(fid);
                    do i=1 to infonum;
                       infoname=foptname(fid, i);
                       infoval=finfo(fid, infoname);
                       output;
                    end;
                 end;
              close=fclose(fid);
              rc = filename('filerefx');
           run;
           """.replace('filerefx', fileref)
   
           if self.nosub:
               print(code)
               return None
           else:
              ll  = self.submit(code, results='text')
   
           res = self.sd2df('_SASPY_FILE_INFO', 'work')
           return res


        code="""options nosource;
        data _null_;
           length infoname infoval $256;
           drop rc fid infonum i close;
           put 'INFOSTART';
           fid=fopen('filerefx');
           if fid then
              do;
                 infonum=foptnum(fid);
                 do i=1 to infonum;
                    infoname=foptname(fid, i);
                    infoval=finfo(fid, infoname);
                    put 'INFONAME=' infoname;
                    put 'INFOVAL=' infoval;
                    put 'ENDINFOVAL=';
                 end;
              end; 
           put 'INFOEND';
           close=fclose(fid);
           rc = filename('filerefx');
        run; options source;
        """.replace('filerefx', fileref)

        if self.nosub:
            print(code)
            return None
        else:
           ll  = self.submit(code, results='text')

        res = {}
        log = ll['LOG'].rpartition('INFOEND')[0].rpartition('INFOSTART')
                                                                                  
        for i in range(log[2].count('INFONAME')):                                    
           log = log[2].partition('INFONAME=')[2].partition('\n')                    
           key = log[0]                                                           
           log = log[2].partition('INFOVAL=')[2].partition('\nENDINFOVAL=')
           val = log[0].strip().replace('\n','')
           res[key] = val                                                         
                                                                                  
        return res
743494
def get_file_contents(self, file_key):
		'''
		'''
		#does not work
		self._raise_unimplemented_error()
		
		uri = '/'.join([self.api_uri,
						self.files_suffix,
						file_key,
						self.file_contents_suffix,
						])
		return self._req('get', uri)
152539
def get_keys(self, key=None):
        
        if key:
            value = _lxc.Container.get_keys(self, key)
        else:
            value = _lxc.Container.get_keys(self)

        if value is False:
            return False
        elif value.endswith("\n"):
            return value.rstrip("\n").split("\n")
        else:
            return value
1105879
def get_feature_from_key(self, feature_key):
    
    feature = self.feature_key_map.get(feature_key)

    if feature:
      return feature

    self.logger.error('Feature "%s" is not in datafile.' % feature_key)
    return None
228975
def get_file_report(self, this_hash):
        
        params = {'api_key': self.api_key, 'hash': this_hash}

        try:
            response_info = requests.get(self.base + 'file/mwsinfo', params=params)
            response_additional = requests.get(self.base + 'file/addinfo', params=params)
        except requests.RequestException as e:
            return dict(error=e.message)

        ri = _return_response_and_status_code(response_info)
        ra = _return_response_and_status_code(response_additional)

        if ri['response_code'] == '1' and ra['response_code'] == '1':  # both ok
            both = ri['results'].copy()
            both.update(ra['results'])
            response = dict(results=both, response_code=1)
        elif ri['response_code'] == '1' and ra['response_code'] == '0':  # advance non exists but standard ok
            response = ri
        elif ri['response_code'] == '2':  # main is still loading
            response = dict(results={}, response_code=2)
        else:  # error generic
            response = ri
        return response
1065102
public BoxFolder.Info getFolderInfo(String folderID) {
        URL url = FOLDER_INFO_URL_TEMPLATE.build(this.api.getBaseURL(), folderID);
        BoxAPIRequest request = new BoxAPIRequest(this.api, url, "GET");
        BoxJSONResponse response = (BoxJSONResponse) request.send();
        JsonObject jsonObject = JsonObject.readFrom(response.getJSON());

        BoxFolder folder = new BoxFolder(this.api, jsonObject.get("id").asString());
        return folder.new Info(response.getJSON());
    }
1351466
def get_list_key(self, data, key, header_lines=1):
        
        data = data.splitlines()
        init = self.get_section_key_line(data, key)
        if init == -1:
            return []
        start, end = self.get_next_section_lines(data[init:])
        # get the spacing of line with key
        spaces = get_leading_spaces(data[init + start])
        start += init + header_lines
        if end != -1:
            end += init
        else:
            end = len(data)

        return self._get_list_key(spaces, data[start:end])
1304527
def fileinfo(fileobj, filename=None, content_type=None, existing=None):
        
        return _FileInfo(fileobj, filename, content_type).get_info(existing)
69868
def get_single_file_info(f_path, int_path):
    
    return { 'path'     : force_unicode(int_path),
             'created'  : os.path.getctime(f_path),
             'last_mod' : os.path.getmtime(f_path)}
110315
def _get_key_info(self):
        """"""
        vkey_scan = LoByte(VkKeyScan(self.key))

        return (vkey_scan, MapVirtualKey(vkey_scan, 0), 0)
238504
def buffer(self, item):
        
        key = self.get_key_from_item(item)
        if not self.grouping_info.is_first_file_item(key):
            self.items_group_files.add_item_separator_to_file(key)
        self.grouping_info.ensure_group_info(key)
        self.items_group_files.add_item_to_file(item, key)
837071
def more_info(self):
        
        print("\nDatabox Instance", self.path)
        print("\nHeader")
        for h in self.hkeys: print("  "+h+":", self.h(h))
        s = "\nColumns ("+str(len(self.ckeys))+"): "
        for c in self.ckeys: s = s+c+", "
        print(s[:-2])