getter for authors - gets The authors of the document, O
@generated
@return value of the feature
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)));}
459934
public function getExampleFormMarkup()
    {
        $authors = AuthorManager::fetch();
        $options = array();

        foreach ($authors as $a) {
            $options[] = array($a->get('id'), null, $a->getFullName());
        }

        $fieldname = 'fields['.$this->get('element_name').']';

        if ($this->get('allow_multiple_selection') === 'yes') {
            $fieldname .= '[]';
        }

        $attr = array();

        if ($this->get('allow_multiple_selection') === 'yes') {
            $attr['multiple'] = 'multiple';
        }

        $label = Widget::Label($this->get('label'));
        $label->appendChild(Widget::Select($fieldname, $options, $attr));

        return $label;
    }
1363970
public AuthorInfo getAuthors(int i) {
    if (Header_Type.featOkTst && ((Header_Type)jcasType).casFeat_authors == null)
      jcasType.jcas.throwFeatMissing("authors", "de.julielab.jules.types.Header");
    jcasType.jcas.checkArrayBounds(jcasType.ll_cas.ll_getRefValue(addr, ((Header_Type)jcasType).casFeatCode_authors), i);
    return (AuthorInfo)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_getRefArrayValue(jcasType.ll_cas.ll_getRefValue(addr, ((Header_Type)jcasType).casFeatCode_authors), i)));}
642664
def get_queryset(self):
        
        self.author = get_object_or_404(
            Author, **{Author.USERNAME_FIELD: self.kwargs['username']})
        return self.author.entries_published()
779479
public static Document getOwnerDocument(Node n) {
    return n == null || !isElement(n) ? null : n.getNodeType() == Node.DOCUMENT_NODE
        ? n.<Document> cast() : n.getOwnerDocument();
  }
7305
public function get_authors()
	{
		$authors = array();
		foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'author') as $author)
		{
			$name = null;
			$uri = null;
			$email = null;
			if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data']))
			{
				$name = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_HTML);
			}
			if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data']))
			{
				$uri = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]));
			}
			if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data']))
			{
				$email = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_HTML);
			}
			if ($name !== null || $email !== null || $uri !== null)
			{
				$authors[] = $this->registry->create('Author', array($name, $uri, $email));
			}
		}
		if ($author = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'author'))
		{
			$name = null;
			$url = null;
			$email = null;
			if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data']))
			{
				$name = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_HTML);
			}
			if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data']))
			{
				$url = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]));
			}
			if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data']))
			{
				$email = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_HTML);
			}
			if ($name !== null || $email !== null || $url !== null)
			{
				$authors[] = $this->registry->create('Author', array($name, $url, $email));
			}
		}
		if ($author = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'author'))
		{
			$authors[] = $this->registry->create('Author', array(null, null, $this->sanitize($author[0]['data'], SIMPLEPIE_CONSTRUCT_HTML)));
		}
		foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'creator') as $author)
		{
			$authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_HTML), null, null));
		}
		foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'creator') as $author)
		{
			$authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_HTML), null, null));
		}
		foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'author') as $author)
		{
			$authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_HTML), null, null));
		}

		if (!empty($authors))
		{
			return array_unique($authors);
		}
		elseif (($source = $this->get_source()) && ($authors = $source->get_authors()))
		{
			return $authors;
		}
		elseif ($authors = $this->feed->get_authors())
		{
			return $authors;
		}
		else
		{
			return null;
		}
	}
783317
public function author()
    {
        foreach($this->data as $post)
        {
            $id = $post->author;

            $author = get_userdata($id);
            $avatar = get_field('author_avatar', 'user_' . $id);
            $banner = get_field('author_banner', 'user_' . $id);

            $author = (object) [
                'name' => $author->display_name,
                'permalink' => get_author_posts_url($id),
                'images' => (object) [
                    'avatar' => $avatar ? $avatar['url'] : false,
                    'banner' => $banner ? $banner['url'] : false
                ]
            ];

            $post->author = $author;
        }

        return $this;
    }
588460
public function get_authors() {
		$authors = array();

		$url = $this->get_value('http://purl.org/ontology/bibo/authorList');
		$info = $this->data[$url];
		foreach ($info as $k => $v) {
			if (strpos($k, '#type') !== false) {
				continue;
			}

			$authors[] = $this->get_author($v[0]['value']);
		}

		return $authors;
	}
197791
public static function getAuthors()
    {
        $query = static::find()
            ->alias('c')
            ->select(['c.createdBy', 'a.username'])
            ->joinWith('author a')
            ->groupBy(['c.createdBy', 'a.username'])
            ->orderBy('a.username')
            ->asArray()
            ->all();

        return ArrayHelper::map($query, 'createdBy', 'author.username');
    }
468174
def author(self):
        """"""
        r = self.site.site_config['default_author']
        if 'author' in self._config:
            r = self._config['author']
        return r
819889
def get_authors(self, language):
        
        return self.gettext(language, self._author) if self._author else ""
265380
public static AuthorInformation getAuthorInformation(final DataProviderFactory providerFactory,
            final ServerEntitiesWrapper serverEntities, final Integer authorId, final Integer revision) {
        final AuthorInformation authInfo = new AuthorInformation();
        authInfo.setAuthorId(authorId);
        TagWrapper tag = null;
        try {
            tag = providerFactory.getProvider(TagProvider.class).getTag(authorId);
        } catch (NotFoundException e) {
            tag = providerFactory.getProvider(TagProvider.class).getTag(authorId, revision);
        }
        if (tag != null && tag.getProperty(serverEntities.getFirstNamePropertyTagId()) != null && tag.getProperty(
                serverEntities.getSurnamePropertyTagId()) != null) {
            authInfo.setFirstName(tag.getProperty(serverEntities.getFirstNamePropertyTagId()).getValue());
            authInfo.setLastName(tag.getProperty(serverEntities.getSurnamePropertyTagId()).getValue());
            if (tag.getProperty(serverEntities.getEmailPropertyTagId()) != null) {
                authInfo.setEmail(tag.getProperty(serverEntities.getEmailPropertyTagId()).getValue());
            }
            if (tag.getProperty(serverEntities.getOrganizationPropertyTagId()) != null) {
                authInfo.setOrganization(tag.getProperty(serverEntities.getOrganizationPropertyTagId()).getValue());
            }
            if (tag.getProperty(serverEntities.getOrganizationDivisionPropertyTagId()) != null) {
                authInfo.setOrgDivision(tag.getProperty(serverEntities.getOrganizationDivisionPropertyTagId()).getValue());
            }
            return authInfo;
        }
        return null;
    }
46979
def get_authors(repo_path, from_commit):
    
    repo = dulwich.repo.Repo(repo_path)
    refs = get_refs(repo)
    start_including = False
    authors = set()

    if from_commit is None:
        start_including = True

    for commit_sha, children in reversed(
        get_children_per_first_parent(repo_path).items()
    ):
        commit = get_repo_object(repo, commit_sha)
        if (
            start_including or commit_sha.startswith(from_commit) or
            fuzzy_matches_refs(from_commit, refs.get(commit_sha, []))
        ):
            authors.add(commit.author.decode())
            for child in children:
                authors.add(child.author.decode())

            start_including = True

    return '\n'.join(sorted(authors))
1204634
def get_authors_as_str(x):
    
    _authors = ""
    # if it's a string already, we're done
    if isinstance(x, str):
        return x

    # elif it's a list, keep going
    elif isinstance(x, list):
        # item in list is a str
        if isinstance(x[0], str):
            # loop and concat until the last item
            for name in x[:-1]:
                # all inner items get a semi-colon at the end
                _authors += str(name) + "; "
            # last item does not get a semi-colon at the end
            _authors += str(x[-1])

        # item in list is a dictionary
        elif isinstance(x[0], dict):
            # dictionary structure SHOULD have authors listed until the "name" key.
            try:
                # loop and concat until the last item
                for entry in x[:-1]:
                    # all inner items get a semi-colon at the end
                    _authors += str(entry["name"]) + "; "
                # last item does not get a semi-colon at the end
                _authors += str(x[-1]["name"])
            except KeyError:
                logger_misc.warn("get_authors_as_str: KeyError: Authors incorrect data structure")

    else:
        logger_misc.debug("get_authors_as_str: TypeError: author/investigators isn't str or list: {}".format(type(x)))

    return _authors
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
798260
def get_publisher_name(self, **kwargs):
        """"""
        children = kwargs.get('children', [])
        # Find the creator type in children.
        for child in children:
            if child.tag == 'name':
                return child.content
        return None
1352283
def get_authors(filepath: str) -> List[str]:
    """"""
    str_oneline = r'(^__author__ = )(\[.*?\])'  # type" str
    comp_oneline = re.compile(str_oneline, re.MULTILINE)  # type: Pattern[str]
    with open(filepath) as file_open:
        file_read = file_open.read()  # type: str
    match = comp_oneline.findall(file_read)
    if match:
        inner_list_as_str = match[0][1]  # type: str
        inner_list = eval_str_to_list(inner_list_as_str)  # type: List[str]
        return inner_list
    return list()