Load the resource from the server, if not already loaded.
192651
def inflate(self):
        """"""
        if not self._is_inflated:
            if self._is_inflating:
                #  catch infinite recursion when attempting to inflate
                #  an object that doesn't have enough data to inflate
                msg = ("There is not enough data to inflate this object.  "
                       "Need either an href: {} or a {}: {}")
                msg = msg.format(self._href, self.primary_key, self._data.get(self.primary_key))
                raise exceptions.ClientError(msg)

            self._is_inflating = True

            try:
                params = self.searchParameters if hasattr(self, 'searchParameters') else {}
                # To keep the method same as the original request. The default is GET
                self.load(self.client.request(self.method, self.url, **params))
            except Exception:
                self.load(self._data)

            self._is_inflated = True
            self._is_inflating = False
        return self
279914
def _load_resource(self, source_r, abs_path=False):
        

        r = self.doc.resource(source_r.name)

        r.url = self.resource_root.join(r.url).inner
1029723
def load_all_resources():
    
    pkgname = resources.__name__
    for importer, mod_name, _ in pkgutil.iter_modules(resources.__path__):
        full_mod_name = '%s.%s' % (pkgname, mod_name)
        if full_mod_name not in sys.modules:
            module = importer.find_module(mod_name
                        ).load_module(full_mod_name)
            log.debug("Loaded resource from: %s", module)
348493
def load(self, model):
        """"""
        self._dawg.load(find_data(model))
        self._loaded_model = True
764127
def reload(self):
        
        self.load(self.api.get(self.objName, self.key))
239984
async def load(self, request):
        """"""
        if SESSION_KEY not in request:
            session = Session(self.cfg.secret, key=self.cfg.session_cookie,
                              max_age=self.cfg.max_age, domain=self.cfg.domain)
            session.load(request.cookies)
            self.app.logger.debug('Session loaded: %s', session)
            request[SESSION_KEY] = request.session = session
        return request[SESSION_KEY]
589736
private function load()
    {
        if (! $this->loaded) {
            $this->databoxes = $this->repository->findAll();
            $this->loaded = true;
        }
    }
146712
def load(self):
        """"""
        # Init the static server list (if defined)
        self.static_server = GlancesStaticServer(config=self.config)

        # Init the password list (if defined)
        self.password = GlancesPassword(config=self.config)
1367028
def load(self):
        """"""
        if self.is_persisted:
            with open(self.file_name, 'rb') as f:
                self.object_property = pickle.load(f)
223239
def load(self):
        """"""
        if self.r.live:
            self.extra_config['collections'] = {'live':
                    {'index': '$live'}}

        if self.r.debug:
            self.extra_config['debug'] = True

        if self.r.record:
            self.extra_config['recorder'] = 'live'
149824
def do_load(self, filename):
        """"""
        try:
            self.__session.load(filename)
        except IOError as e:
            self.logger.error(e.strerror)
662475
private Resource loadResource(String name, Locale locale, String encoding) throws IOException {
        Resource resource;
        if (stringLoader.exists(name, locale)) {
            resource = stringLoader.load(name, locale, encoding);
        } else {
            resource = loader.load(name, locale, encoding);
        }
        if (resource == null) {
            throw new FileNotFoundException("Not found resource " + name);
        }
        return resource;
    }
275580
private function load()
    {

        $this->initialize();
        $this->dataConnector->loadResourceLinkShareKey($this);
        if (!is_null($this->id)) {
            $this->length = strlen($this->id);
        }
        if (!is_null($this->expires)) {
            $this->life = ($this->expires - time()) / 60 / 60;
        }

    }
655380
def _load(self):
        """"""
        self.wavelength, self.irradiance = \
            np.genfromtxt(self.filename, unpack=True)
341222
def load_server!
      if @server_name
        unless SERVERS.has_key?(@server_name)
          raise(UnknownServer,"Unknown server name #{@server_name}",caller)
        end

        extend SERVERS[@server_name]

        initialize_server if respond_to?(:initialize_server)
      end
    end
227087
def load(self):
        """"""
        if not op.exists(self.path):
            logger.debug("The GUI state file `%s` doesn't exist.", self.path)
            # TODO: create the default state.
            return
        assert op.exists(self.path)
        logger.debug("Load the GUI state from `%s`.", self.path)
        self.update(_bunchify(_load_json(self.path)))
214870
public function load()
    {
        if ($this->loaded) {
            throw new \LogicException('The status is already loaded. Use another instance.');
        }

        $this->attributes = array_merge($this->attributes, $this->client->hgetall($this->getHashKey()));
        $this->loaded     = true;
    }