Read and return the content of the project README file.
486174
def get_readme():
    """"""
    base_dir = path.abspath(path.dirname(__file__))
    with open(path.join(base_dir, 'README.md'), encoding='utf-8') as readme_f:
        return readme_f.read()
369050
def get_readme():
    ''

    here = path.abspath(path.dirname(__file__))
    with open(path.join(here, 'README.rst'), encoding='utf-8') as my_fd:
        result = my_fd.read()

    return result
1135106
def read(self, filepath):
        """"""
        target = self._read_check(filepath)

        if os.path.isfile(target):
            with open(target) as f:
                string = f.read()

            #If we got this file via SSH, delete it from the temp folder
            if self.is_ssh(filepath):
                os.remove(target)
        else:
            string = ""

        return string
583202
def process_readme():
    
    with open('../../README.md', 'r') as file:
        readme = file.read()

    readme = readme.replace('# eo-learn', '# Introduction').replace('docs/source/', '')
    readme = readme.replace('**`', '**').replace('`**', '**')

    chapters = [[]]
    for line in readme.split('\n'):
        if line.strip().startswith('## '):
            chapters.append([])
        if line.startswith('<img'):
            line = '<p></p>'

        chapters[-1].append(line)

    chapters = ['\n'.join(chapter) for chapter in chapters]

    intro = '\n'.join([chapter for chapter in chapters if not (chapter.startswith('## Install') or
                                                               chapter.startswith('## Documentation'))])
    install = '\n'.join([chapter for chapter in chapters if chapter.startswith('## Install')])

    with open(os.path.join(MARKDOWNS_FOLDER, 'INTRO.md'), 'w') as file:
        file.write(intro)
    with open(os.path.join(MARKDOWNS_FOLDER, 'INSTALL.md'), 'w') as file:
        file.write(install)
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()
307999
private ProjectFile read() throws Exception
   {
      m_project = new ProjectFile();
      m_eventManager = m_project.getEventManager();

      m_project.getProjectProperties().setFileApplication("Synchro");
      m_project.getProjectProperties().setFileType("SP");

      CustomFieldContainer fields = m_project.getCustomFields();
      fields.getCustomField(TaskField.TEXT1).setAlias("Code");

      m_eventManager.addProjectListeners(m_projectListeners);

      processCalendars();
      processResources();
      processTasks();
      processPredecessors();

      return m_project;
   }
518917
def get_long_description():
    

    with open(
        os.path.join(BASE_DIRECTORY, 'README.md'),
        'r',
        encoding='utf-8'
    ) as readme_file:
        return readme_file.read()
550559
def read(fname, URL, URLImage):
    """"""
    readme = open(path.join(path.dirname(__file__), fname)).read()
    if hasattr(readme, 'decode'):
        # In Python 3, turn bytes into str.
        readme = readme.decode('utf8')
    # turn relative links into absolute ones
    readme = re.sub(r'`<([^>]*)>`__',
                    r'`\1 <' + URL + r"/blob/master/\1>`__",
                    readme)
    readme = re.sub(r"\.\. image:: /", ".. image:: " + URLImage + "/", readme)

    return readme
740414
def read_content(self):
        """"""
        buf = StringIO()
        data = self.read_content_chunk()
        while data:
            if buf.tell() + len(data) > self.aggregate.config["maxfilesizedownload"]:
                raise LinkCheckerError(_("File size too large"))
            buf.write(data)
            data = self.read_content_chunk()
        return buf.getvalue()
987125
public ProjectFile read() throws MPXJException
   {
      try
      {
         m_project = new ProjectFile();
         m_eventManager = m_project.getEventManager();

         ProjectConfig config = m_project.getProjectConfig();
         config.setAutoTaskID(false);
         config.setAutoTaskUniqueID(false);
         config.setAutoResourceID(false);
         config.setAutoResourceUniqueID(false);
         config.setAutoOutlineLevel(false);
         config.setAutoOutlineNumber(false);
         config.setAutoWBS(false);
         config.setAutoCalendarUniqueID(false);
         config.setAutoAssignmentUniqueID(false);

         m_project.getProjectProperties().setFileApplication("Microsoft");
         m_project.getProjectProperties().setFileType("MPD");

         m_project.getEventManager().addProjectListeners(m_projectListeners);

         processProjectProperties();
         processCalendars();
         processResources();
         processResourceBaselines();
         processTasks();
         processTaskBaselines();
         processLinks();
         processAssignments();
         processAssignmentBaselines();
         processExtendedAttributes();
         processSubProjects();
         postProcessing();

         return (m_project);
      }

      catch (SQLException ex)
      {
         throw new MPXJException(MPXJException.READ_ERROR, ex);
      }

      finally
      {
         reset();

         if (m_allocatedConnection && m_connection != null)
         {
            try
            {
               m_connection.close();
            }

            catch (SQLException ex)
            {
               // silently ignore errors on close
            }

            m_connection = null;
         }
      }
   }
787601
protected function dumpReadmeFile()
    {
        $readmeContents = sprintf("%s\n%s\n\nA Symfony project created on %s.\n", $this->projectName, str_repeat('=', strlen($this->projectName)), date('F j, Y, g:i a'));
        try {
            $this->fs->dumpFile($this->projectDir.'/README.md', $readmeContents);
        } catch (\Exception $e) {
            // don't throw an exception in case the file could not be created,
            // because this is just an enhancement, not something mandatory
            // for the project
        }

        return $this;
    }
431206
def get_file_contents(file_path):
  """"""
  full_path = os.path.join(package_dir, file_path)
  return open(full_path, 'r').read()
418744
def _generate_readme_text(self, object_tree_path):
        """"""

        wdef_folder = self._object_tree.get_source_tree_folder(object_tree_path)
        res = StringIO()
        if len(object_tree_path):
            folder_name = object_tree_path[-1]
        else:
            folder_name = 'root'
        header = 'ObjectTree Folder "{}"'.format(folder_name)
        res.write(header + '\n')
        res.write('{}\n\n'.format('=' * len(header)))
        res.write(
            'The content present in object_tree folders is determined by a list\n'
        )
        res.write(
            'of specific identifiers and by queries applied against the DataONE\n'
        )
        res.write('search index.\n\n')
        res.write('Queries:\n\n')
        if len(wdef_folder['queries']):
            for query in wdef_folder['queries']:
                res.write('- {}\n'.format(query))
        else:
            res.write('No queries specified at this level.\n')
        res.write('\n\n')
        res.write('Identifiers:\n\n')
        if len(wdef_folder['identifiers']):
            for pid in wdef_folder['identifiers']:
                res.write('- {}\n'.format(pid))
        else:
            res.write('No individual identifiers selected at this level.\n')
        res.write('\n\n')
        res.write('Sub-folders:\n\n')
        if len(wdef_folder['collections']):
            for f in wdef_folder['collections']:
                res.write('- {}\n'.format(f))
        else:
            res.write('No object_tree sub-folders are specified at this level.\n')
        return res.getvalue().encode('utf-8')
771709
private String readMessage(String pFileName) {
        try {
            // Read resource from web app
            InputStream is = getServletContext().getResourceAsStream(pFileName);

            if (is != null) {
                return new String(FileUtil.read(is));
            }
            else {
                log("File not found: " + pFileName);
            }
        }
        catch (IOException ioe) {
            log("Error reading file: " + pFileName + " (" + ioe.getMessage() + ")");
        }
        return null;
    }
920871
def get_dataset(self, key, info):
        """"""
        logger.debug("Reading %s.", key)
        return self.file_content[key.name]
600280
def parse_readme():
    
    name = None
    re_mod = re.compile(r'^\#\#\# <a name="(?P<name>[a-z_0-9]+)"></a>')
    readme_file = os.path.join(modules_directory(), "README.md")
    modules_dict = {}
    with open(readme_file) as f:
        for row in f.readlines():
            match = re_mod.match(row)
            if match:
                name = match.group("name")
                modules_dict[name] = []
                continue
            if row.startswith("---"):
                name = None
                continue
            if name:
                modules_dict[name].append(row)
    return modules_dict
628471
def read(self):
        # type: () -> Optional[str]
        
        with open(self.version_file) as fp:
            content = fp.read()
            m = RE_PY_VERSION.search(content)
            if not m:
                return None
            else:
                return m.group('version')