Get abbreviations of the names of the author.

        :return: a list of strings (empty list if no abbreviations available).
978280
def get_abbreviations(self):
        
        abbreviations = []
        try:
            type_abbreviation = self.session.get_resource(BASE_URI_TYPES % "abbreviation"
                                                        , self.session.get_class(surf.ns.ECRM['E55_Type']))
            abbreviations = [unicode(label)
                                for name in self.ecrm_P1_is_identified_by
                                    for abbreviation in name.ecrm_P139_has_alternative_form
                                        for label in abbreviation.rdfs_label
                                            if name.uri == surf.ns.EFRBROO['F12_Name']
                                                and abbreviation.ecrm_P2_has_type.first == type_abbreviation]
        except Exception as e:
            logger.debug("Exception raised when getting abbreviations for %a"%self)
        finally:
            return abbreviations
607646
def get_authors(self):
        
        Person = self._session.get_class(surf.ns.EFRBROO['F10_Person'])
        return list(Person.all())
1330058
def _author_line(self):
        
        if self.author and self.institution:
            return self.author + ";" + self.institution
        elif self.author:
            return self.author
        else:
            return self.institution
368676
def _get_surnames(self):
        
        names = self._read_name_file('surnames.json')
        names = self._compute_weights(names)

        return names
1085539
def name(self):
        
        if hasattr(self.user, "get_full_name"):
            return self.user.get_full_name()
        return "{0}".format(self.user)
1356615
def names(self) -> [str]:
        
        return sorted([name for name in self.axes_by_sname.keys() if name is not ''])
380232
def get_suffixes():
    

    names = []

    if at_least_libvips(8, 8):
        array = vips_lib.vips_foreign_get_suffixes()
        i = 0
        while array[i] != ffi.NULL:
            name = _to_string(array[i])
            if name not in names:
                names.append(name)
            glib_lib.g_free(array[i])
            i += 1
        glib_lib.g_free(array)

    return names
651865
def get_names(self):
        
        names = [id for id in self.ecrm_P1_is_identified_by if id.uri == surf.ns.EFRBROO['F12_Name']]
        self.names = []
        for name in names:
            for variant in name.rdfs_label:
                self.names.append((variant.language,variant.title()))
        return self.names
119397
def author(self):
        
        if self.api and self.author_id:
            return self.api._get_user(self.author_id)
583356
def get_authors(apikey, username, password):
    
    authenticate(username, password)
    return [author_structure(author)
            for author in Author.objects.filter(is_staff=True)]
730483
def extract_abbreviations(fulltext):
    
    acronyms = {}
    for k, v in get_acronyms(fulltext).items():
        acronyms[KeywordToken(k, type='acronym')] = v
    return acronyms
347814
def names(self):
        
        found_names = []
        with open(self.filename) as f:
            content = f.readlines()
        for line in content:
            line = line.strip()
            if " " in line:
                attribute, value = line.split(" ", 1)
                attribute = attribute.strip()
                value = value.strip()
                if attribute.lower() in ['host']:
                    found_names.append(value)
        return found_names
551414
def get_geo_index():
    
    _dict = {}
    for k, v in AUTHOR_EPITHET.items():
        _dict[k] = set(v)

    return _dict
1338195
def authors(self, *usernames):
        
        if len(usernames) == 1:
            return self.filter(**{"author__{}".format(User.USERNAME_FIELD): usernames[0]})
        else:
            return self.filter(**{"author__{}__in".format(User.USERNAME_FIELD): usernames})
733875
def get_one_author(author)
      return { "literal" => "" } if author.strip.blank?

      author = cleanup_author(author)
      names = Namae.parse(author)

      if names.blank? || is_personal_name?(author).blank?
        { "literal" => author }
      else
        name = names.first

        { "family" => name.family,
          "given" => name.given }.compact
      end
    end
352862
def get_author(self, **kwargs):
        """"""
        qualifier = kwargs.get('qualifier', '')
        children = kwargs.get('children', [])
        creator_type_per = False
        author_name = None
        # Find the creator type in children.
        for child in children:
            if child.tag == 'type' and child.content == 'per':
                creator_type_per = True
            # Get the author name.
            elif child.tag == 'name':
                author_name = child.content
        if qualifier == 'aut' and creator_type_per and author_name:
            return author_name

        return None
194645
public FSArray getAuthors() {
    if (Header_Type.featOkTst && ((Header_Type)jcasType).casFeat_authors == null)
      jcasType.jcas.throwFeatMissing("authors", "de.julielab.jules.types.Header");
    return (FSArray)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_getRefValue(addr, ((Header_Type)jcasType).casFeatCode_authors)));}