Load the page. The _file_name param is known, because this
        method is only called after having checked that the page exists.
13979
def _load(self, slug):
        
        #here we know that the slug exists
        self._slug = slug
        page_dir = os.path.join(self.site.dirs['source'], self._slug)
        page_file_name = os.path.join(page_dir, self._slug + '.md')
        self._dirs['source_dir'] = page_dir
        self._dirs['source_filename'] = page_file_name
        self._dirs['www_dir'] = os.path.join(self.site.dirs['www'], slug)
        self._dirs['www_filename'] = os.path.join(self._dirs['www_dir'],  'index.html')

        #pf = open(self._dirs['source_filename'], 'r')
        #page_text = pf.read()
        #pf.close()
        # need to decode!
        pf = codecs.open(self._dirs['source_filename'], mode="r", encoding="utf-8")
        page_text = pf.read()
        pf.close()

        self._parse_text(page_text)
        if not self._check_config():
            raise ValueError
            #sys.exit()
        self._title = self._config['title'][0]
701955
def load_from_filename(self, file_name, sep='\n'):
        """"""
        fp = open(file_name, 'rb')
        n = self.load_from_file(fp, sep)
        fp.close()
        return n
713494
def _load(self):
        
        while True:
            tarinfo = self.next()
            if tarinfo is None:
                break
        self._loaded = True
965291
def load(cls, filename, schema_only=False):
        
        o = open(filename)
        s = o.read()
        a = cls.parse(s, schema_only=schema_only)
        if not schema_only:
            a._filename = filename
        o.close()
        return a
1078748
def load(self, *args, **kwargs):
        
        response = self.http.send(self.url)
        if response.status_code == 200:
            _txt = response.content
            return self.parse_and_check_signature(_txt)
        else:
            logger.info("Response status: %s", response.status_code)
            raise SourceNotFound(self.url)
777371
def _load_from_file(self, filename):
    """"""
    if not tf.gfile.Exists(filename):
      raise ValueError("File %s not found" % filename)
    with tf.gfile.Open(filename) as f:
      self._load_from_file_object(f)
994002
def loadFile(self, fileName):
        
        self.fileName = fileName
        self.qteWeb.load(QtCore.QUrl(fileName))
1161526
def load_filename(self, filename, index=None):
        
        filename = str(filename)  # QString protection
        if index is None:
            index = self._get_tab_index()
        page = self.pages[index]

        # Maybe this is set on purpose before loading attempt to leave new load_dir set (?)
        self.load_dir, _ = os.path.split(filename)

        clss = page.clss_load
        if len(clss) == 1:
            # If there is only one class to handle the file, will load it in a way that eventual
            # load errors will raise
            f = clss[0]()
            f.load(filename)
        else:
            # At the moment, the multi-class alternative will not display particular error information
            # if the file does not load
            f = f311.load_with_classes(filename, page.clss_load)
            if f is None:
                raise RuntimeError("Could not load '{0!s}'".format(filename))

        self.load(f, index)
1011528
def load
      return unless File.exist?(@path) && !loaded?

      @source = File.read(@path)
      context = Context.new(self)
      eval @source, context.binding, @path.to_s, 1 # rubocop:disable Lint/Eval
      @loaded = true
    end
971503
def from_file(self, file_name=None):
        """"""

        file_name = self._check_file_name(file_name)

        with open(file_name, 'r') as infile:
            top_level_dict = json.load(infile)

        pages_dict = top_level_dict['info_df']
        pages = pd.DataFrame(pages_dict)
        self.pages = pages
        self.file_name = file_name
        self._prm_packer(top_level_dict['metadata'])
        self.generate_folder_names()
        self.paginate()
149824
def do_load(self, filename):
        """"""
        try:
            self.__session.load(filename)
        except IOError as e:
            self.logger.error(e.strerror)
593566
def _load(self):
        
        try:
            get = requests.get(self._ref,
                               verify=self.http_verify,
                               auth=self.auth,
                               timeout=self.timeout)
        except requests.exceptions.RequestException as err:
            raise NotFoundError(err)
        return get.content
722914
public function load_file()
	{
		$args = func_get_args();
		$this->load(call_user_func_array('file_get_contents', $args), true);
		// Throw an error if we can't properly load the dom.
		if (($error=error_get_last())!==null) {
			$this->clear();
			return false;
		}
	}
1046379
def load_file(self, file):
        

        if not foundations.common.path_exists(file):
            raise foundations.exceptions.FileExistsError(
                "{0} | '{1}' file doesn't exists!".format(self.__class__.__name__,
                                                          file))

        LOGGER.debug("> Loading '{0}' file.".format(file))
        reader = foundations.io.File(file)
        self.setPlainText(reader.read())
        self.set_file(file)
        self.__set_document_signals()
        self.file_loaded.emit()
        return True
872714
async def load(self, file_path, locale=None, flags=None):
        

        await self.start(file_path, locale, {'flags': flags})
731992
def load(self, filething):
        

        fileobj = filething.fileobj

        try:
            self.info = self._Info(fileobj)
            self.tags = self._Tags(fileobj, self.info)
            self.info._post_tags(fileobj)
        except (error, IOError) as e:
            reraise(self._Error, e, sys.exc_info()[2])
        except EOFError:
            raise self._Error("no appropriate stream found")
975054
def __load(self, redirect=True, preload=False):
        
        query_params = {
            "prop": "info|pageprops",
            "inprop": "url",
            "ppprop": "disambiguation",
            "redirects": "",
        }
        query_params.update(self.__title_query_param())

        request = self.mediawiki.wiki_request(query_params)

        query = request["query"]
        pageid = list(query["pages"].keys())[0]
        page = query["pages"][pageid]

        # determine result of the request
        # missing is present if the page is missing
        if "missing" in page:
            self._raise_page_error()
        # redirects is present in query if page is a redirect
        elif "redirects" in query:
            self._handle_redirect(redirect, preload, query, page)
        # if pageprops is returned, it must be a disambiguation error
        elif "pageprops" in page:
            self._raise_disambiguation_error(page, pageid)
        else:
            self.pageid = pageid
            self.title = page["title"]
            self.url = page["fullurl"]