return package's long description
324692
def get_long_description():
    """"""
    base = os.path.abspath(os.path.dirname(__file__))
    readme_file = os.path.join(base, 'README.md')
    with open(readme_file, mode='rt', encoding='utf-8') as readme:
        return readme.read()
1127059
def read_long_description(readme_file):
    
    try:
        import pypandoc
    except (ImportError, OSError) as e:
        print('No pypandoc or pandoc: %s' % (e,))
        if is_py3:
            fh = open(readme_file, encoding='utf-8')
        else:
            fh = open(readme_file)
        long_description = fh.read()
        fh.close()
        return long_description
    else:
        return pypandoc.convert(readme_file, 'rst')
1354465
def info(package, long_description, classifiers, license):
    
    client = requests.Session()
    for name_or_url in package:
        package = get_package(name_or_url, client)
        if not package:
            secho(u'Invalid name or URL: "{name}"'.format(name=name_or_url),
                  fg='red', file=sys.stderr)
            continue

        # Name and summary
        try:
            info = package.data['info']
        except NotFoundError:
            secho(u'No versions found for "{0}". '
                  u'Skipping. . .'.format(package.name),
                  fg='red', file=sys.stderr)
            continue
        echo_header(name_or_url)
        if package.summary:
            echo(package.summary)

        # Version info
        echo()
        echo('Latest release:   {version:12}'.format(version=info['version']))

        # Long description
        if long_description:
            echo()
            echo(package.description)

        # Download info
        echo()
        echo_download_summary(package)

        # Author info
        echo()
        author, author_email = package.author, package.author_email
        if author:
            echo(u'Author:   {author:12}'.format(**locals()))
        if author_email:
            echo(u'Author email: {author_email:12}'.format(**locals()))

        # Maintainer info
        maintainer, maintainer_email = (package.maintainer,
                                        package.maintainer_email)
        if maintainer or maintainer_email:
            echo()
        if maintainer:
            echo(u'Maintainer:   {maintainer:12}'.format(**locals()))
        if maintainer_email:
            echo(u'Maintainer email: {maintainer_email:12}'.format(**locals()))

        # URLS
        echo()
        echo(u'PyPI URL:  {pypi_url:12}'.format(pypi_url=package.package_url))
        if package.home_page:
            echo(u'Home Page: {home_page:12}'.format(
                home_page=package.home_page))
        if package.docs_url:
            echo(u'Documentation: {docs_url:12}'.format(
                docs_url=package.docs_url))

        # Classifiers
        if classifiers:
            echo()
            echo(u'Classifiers: ')
            for each in info.get('classifiers', []):
                echo('\t' + each)

        if license and package.license:
            echo()
            echo(u'License: ', nl=False)
            # license may be just a name, e.g. 'BSD' or the full license text
            # If a new line is found in the text, print a new line
            if package.license.find('\n') >= 0 or len(package.license) > 80:
                echo()
            echo(package.license)
        echo()
1149841
def holiday_description(self):
        
        entry = self._holiday_entry()
        desc = entry.description
        return desc.hebrew.long if self.hebrew else desc.english
18124
def description(self, platform, key):
        """"""
        patterns = self._dict_dscr.get(platform, None)
        description = patterns.get(key, None)
        return description
78021
def get_description(self):
        """"""
        message = self._get_description_message()
        data = self._parse_description(message)
        return data
1351232
def parse_readme():
    """"""
    # Get the long description from the relevant file
    here = os.path.abspath(os.path.dirname(__file__))
    readme_path = os.path.join(here, 'README.md')
    with codecs.open(readme_path, encoding='utf-8') as handle:
        long_description = handle.read()

    return long_description
233347
def parse_readme():
    """"""
    # Get the long description from the relevant file
    readme_file = str(Path(__file__).parent / 'README.rst')
    with codecs.open(readme_file, encoding='utf-8') as handle:
        long_description = handle.read()

    return long_description
1210555
def make_long_description():
    
    readme_path = README_PATH

    # Remove our HTML comments because PyPI does not allow it.
    # See the setup.py docstring for more info on this.
    readme_md = strip_html_comments(read(readme_path))
    history_md = strip_html_comments(read(HISTORY_PATH))
    license_md = """\
License
=======

""" + read(LICENSE_PATH)

    sections = [readme_md, history_md, license_md]
    md_description = '\n\n'.join(sections)

    # Write the combined Markdown file to a temp path.
    md_ext = os.path.splitext(readme_path)[1]
    md_description_path = make_temp_path(RST_DESCRIPTION_PATH, new_ext=md_ext)
    write(md_description, md_description_path)

    rst_temp_path = make_temp_path(RST_DESCRIPTION_PATH)
    long_description = convert_md_to_rst(md_path=md_description_path,
                                         rst_temp_path=rst_temp_path)

    return "\n".join([RST_LONG_DESCRIPTION_INTRO, long_description])
719622
def get_long_description():
    
    with open(path.join(root_path, 'README.md'), encoding='utf-8') as f:
        long_description = f.read()
    return long_description
709812
def package_name(package):
    # type: (str) -> str
    
    if not package:
        return ""

    lastdot = package.rfind(".")
    if lastdot == -1:
        return package

    return package[:lastdot]
1312478
def read_long_description(readme_file):
    
    try:
        import pypandoc
    except (ImportError, OSError) as exception:
        print('No pypandoc or pandoc: %s' % (exception,))
        if sys.version_info.major == 3:
            handle = open(readme_file, encoding='utf-8')
        else:
            handle = open(readme_file)
        long_description = handle.read()
        handle.close()
        return long_description
    else:
        return pypandoc.convert(readme_file, 'rst')
987754
def get_long_description():
    """"""
    try:
        with open('README.md', 'r') as f:
            description = f.read()
    except OSError as e:
        if e.errno != errno.ENOENT:
            raise
        return None

    try:
        process = subprocess.Popen([
                'pandoc',
                '-f', 'markdown_github',
                '-t', 'rst',
            ],
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            universal_newlines=True,
            )
    except OSError as e:
        if e.errno == errno.ENOENT:
            return None
        raise

    description, __ = process.communicate(input=description)
    if process.poll() is None:
        process.kill()
        raise Exception("pandoc did not terminate")
    if process.poll():
        raise Exception("pandoc terminated abnormally")

    return description
987473
def formatted_description(self):
        
        desc = self.description

        if desc:
            return desc.replace("%s1", self.formatted_value)
        else:
            return None
382163
def _get_short_description(self):
        

        if self.description is None:
            return None

        lines = [x for x in self.description.split('\n')]
        if len(lines) == 1:
            return lines[0]
        elif len(lines) >= 3 and lines[1] == '':
            return lines[0]

        return None
231013
def describe(self):
        """"""
        result = "No description available"
        if self.description:
            result = "%s" % self.description
        else:
            if self.__doc__:
                s = []
                s += [self.__doc__.strip().replace('\n', '').
                      replace('    ', ' ')]
                result = '\n'.join(s)
        return result
238012
def long_description():
    """"""
    # use re.compile() for flags support in Python 2.6
    pattern = re.compile(r'\n^\.\. start-badges.*^\.\. end-badges\n',
                         flags=re.M | re.S)
    return pattern.sub('', read('README.rst'))