Information about retinas
        Args:
            retina_name, str: The retina name (optional) (optional)
            Returns: Array[Retina]
489783
def getRetinas(self, retina_name=None):
        

        resourcePath = '/retinas'
        method = 'GET'

        queryParams = {}
        headerParams = {'Accept': 'Application/json', 'Content-Type': 'application/json'}
        postData = None

        queryParams['retina_name'] = retina_name
        response = self.apiClient._callAPI(resourcePath, method, queryParams, postData, headerParams)
        return [retina.Retina(**r) for r in response.json()]
921719
def info(name):
    '''
    
    '''
    try:
        grinfo = grp.getgrnam(name)
    except KeyError:
        return {}
    else:
        return {'name': grinfo.gr_name,
                'passwd': grinfo.gr_passwd,
                'gid': grinfo.gr_gid,
                'members': grinfo.gr_mem}
876785
def get_all_aminames(i_info):
    
    for i in i_info:
        try:
            # pylint: disable=maybe-no-member
            i_info[i]['aminame'] = EC2R.Image(i_info[i]['ami']).name
        except AttributeError:
            i_info[i]['aminame'] = "Unknown"
    return i_info
384218
def get_gene_name(cls, entry):
        
        gene_name = entry.find("./gene/name[@type='primary']")

        return gene_name.text if gene_name is not None and gene_name.text.strip() else None
176579
def gene_ids_of_gene_name(self, gene_name):
        
        results = self._query_gene_ids("gene_name", gene_name)
        if len(results) == 0:
            raise ValueError("Gene name not found: %s" % gene_name)
        return results
1282431
def _get_input_names(spec):
    
    retval = [feature.name for feature in spec.description.input]
    return retval
41841
def contacts(self,*args,**kwargs):
        
        n = Contacts.read_cellframe(self,prune_neighbors=True)
        if 'measured_regions' in kwargs: n.measured_regions = kwargs['measured_regions']
        else: n.measured_regions = self.get_measured_regions()
        if 'measured_phenotypes' in kwargs: n.measured_phenotypes = kwargs['measured_phenotypes']
        else: n.measured_phenotypes = self.phenotypes
        n.microns_per_pixel = self.microns_per_pixel
        return n
262370
public Retina getLanguage (String body) throws ApiException {
         // verify required params are set
         if(body == null ) {
              throw new ApiException(400, "missing required params");
         }
         // create path and map variables
         String path = "/text/detect_language".replaceAll("\\{format\\}","json");

         // query params
         Map<String, String> queryParams = new HashMap<String, String>();
         Map<String, String> headerParams = new HashMap<String, String>();

         String contentType = "application/json";

         try {
             Object response = apiInvoker.invokeAPI(basePath, path, "POST", queryParams
                 , body, headerParams, contentType);
             if(response != null) {
                 if (response instanceof String) {
                         @SuppressWarnings("unchecked")
                         Retina result = (Retina) ApiInvoker.deserialize( (String) response, ""
                                 , Retina.class, null);return result;
                 }
                 else if (response instanceof java.io.ByteArrayInputStream) {
                         @SuppressWarnings("unchecked")
                         Retina result =    (Retina) response;return result;
                 }
                 
             }
             else {
                 return null;
             }
         } catch (ApiException ex) {
             if(ex.getCode() == 404) {
                 return null;
             }
             else {
                 throw ex;
             }
         }
         return null;}
1298513
def get_display_name(value):
    
    display_name = DisplayName()
    token, value = get_phrase(value)
    display_name.extend(token[:])
    display_name.defects = token.defects[:]
    return display_name, value
245073
def get_table_names(self, connection, schema=None, **kw):
        
        return self._get_table_or_view_names('r', connection, schema, **kw)
809849
def getBiosampleByName(self, name):
        
        if name not in self._biosampleNameMap:
            raise exceptions.BiosampleNameNotFoundException(name)
        return self._biosampleNameMap[name]
239599
def get_display_types():
    
    display_types = OrderedDict()
    for namespace in get_supported_libraries():
        display_types[namespace] = get_choices('luma.{0}.device'.format(
            namespace))

    return display_types
251058
def name_to_int(name):
    
    if not name:
        return float('nan')
    lower = name.lower()
    cga_names = {s: i for i, s in enumerate(colour_names.cga())}
    return cga_names.get(lower) or html_to_small_ansi(lower)
1011261
def get(self, name: str, default: Any = None) -> np.ndarray:
		
		if name in self:
			return self[name]
		else:
			return default
1187396
def getKeywordsForText(self, retina_name, body, ):
        

        resourcePath = '/text/keywords'
        method = 'POST'

        queryParams = {}
        headerParams = {'Accept': 'Application/json', 'Content-Type': 'application/json'}
        postData = None

        queryParams['retina_name'] = retina_name
        postData = body
        response = self.apiClient._callAPI(resourcePath, method, queryParams, postData, headerParams)
        return response.json()
1006929
def info
      {
        name: name,
        rgb: rgb,
        hsb: hsb,
        hex: hex,
        mode: mode,
        dark: dark?
      }
    end
1167857
def get_other_gene_names(cls, entry):
        
        alternative_gene_names = []

        for alternative_gene_name in entry.iterfind("./gene/name"):

            if alternative_gene_name.attrib['type'] != 'primary':

                alternative_gene_name_dict = {
                    'type_': alternative_gene_name.attrib['type'],
                    'name': alternative_gene_name.text
                }

                alternative_gene_names.append(models.OtherGeneName(**alternative_gene_name_dict))

        return alternative_gene_names