Try to load a file automatically with ParmEd. Not guaranteed to work, but
        might be useful if it succeeds.

        Arguments
        ---------
        path : str
            Path to file that ParmEd can load
971470
def from_parmed(cls, path, *args, **kwargs):
        
        st = parmed.load_file(path, structure=True, *args, **kwargs)
        box = kwargs.pop('box', getattr(st, 'box', None))
        velocities = kwargs.pop('velocities', getattr(st, 'velocities', None))
        positions = kwargs.pop('positions', getattr(st, 'positions', None))
        return cls(master=st, topology=st.topology, positions=positions, box=box,
                   velocities=velocities, path=path, **kwargs)
676487
def load(self, path):
        
        self.dct = wrapper.Dictionary.load(path)
        return self
454239
def load_yaml_config_file(path):
    
    result = None
    with open(path, 'r') as steam:
        result = yaml.safe_load(steam)
    return result
552505
def load(path)
      raise unless disk_cache_enabled?

      cached_file = File.open(path, "rb")
      value = Marshal.load(cached_file)
      cached_file.close
      value
    end
1301514
def read_file(path, verbose=False):
    
    for filehandle in filehandles(path, verbose=verbose):
        return CTfile.load(filehandle)
365130
def load_directory(path)

      unless File.directory?(path)
        raise "Konfig couldn't load because it was unable to access #{ path }. Please make sure the directory exists and has the correct permissions."
      end

      Dir[File.join(path, "*.yml")].each { |f| load_file(f) }
    end
154944
def load(path):
    
    f = open(path, 'rb')
    try:
        return pickle.load(f)
    finally:
        f.close()
1279804
def load(self, path):
        
        try:
            self._load_binary(path)
        except CLIPSError:
            self._load_text(path)
329210
def load(self, path):
        
        with open(path) as f:
            self.config = full_load(f)
            if self.config is None:
                sys.stderr.write("Warning: config file is empty!\n")
                self.config = {}
435986
def load_file(path, key_word)
      begin
        data = MultiJson.load(IO.read(File.expand_path(path)), symbolize_keys: true)
      rescue RuntimeError, Errno::ENOENT => e
        raise e.message
      rescue MultiJson::LoadError => e
        raise e.message
      end
        if data.has_key?(key_word)
        data[key_word].map { |k,v| data[key_word][k] = v } if data[key_word].is_a? Hash
      end
      data
    end
1160902
def add_load_path(path)
      if path = parse_load_paths(path).first # only accept first one.
        self.load_paths << path
        self.load_paths.uniq!
        return reload(true)  # Load Paths have changed so force a reload
      end
      false
    end
464611
def load(self, path, name):
        

        filename = name + '.fgic'
        filepath = aux.joinpath(path, filename)
        with zipfile.ZipFile(filepath, 'r') as containerZip:
            #Convert the zipfile data into a str object, necessary since
            #containerZip.read() returns a bytes object.
            jsonString = io.TextIOWrapper(containerZip.open('data'),
                                          encoding='utf-8'
                                          ).read()
            infoString = io.TextIOWrapper(containerZip.open('info'),
                                          encoding='utf-8'
                                          ).read()
        self.container = json.loads(jsonString, object_hook=Fgi.jsonHook)
        self.info.update(json.loads(infoString))
        self._matrixTemplate = self.info['_matrixTemplate']
        del self.info['_matrixTemplate']
980739
def load_path(path)
      path = path.to_s
      check_error_string do
        @path = Pathname.new(path)
        load_path_impl(path)
      end
      self
    end
435509
def load_file(self, app, pathname, relpath, pypath):
        
        try:
            view_class = self.get_file_view_cls(relpath)
            return create_view_from_file(pathname, source_template=relpath, view_class=view_class)
        except DeclarativeViewError:
            pass
1163683
def load(filepath):
        '''
        
        '''

        try:
            with open(filepath, "r") as fh:
                source = fh.read()
        except Exception as e:
            return None, e
        return source, None
726288
def load_file(path):
    
    res = {}

    if not path:
        IOError("No path specified to save")

    if not os.path.isfile(path):
        raise IOError("File not found {}".format(path))

    try:
        with io.open(path, "r", encoding="utf-8") as f:
            if path.endswith(".json"):
                res = load_json_file(f)
            elif path.endswith(".yaml") or path.endswith(".yml"):
                res = load_yaml_file(f)
    except IOError:
        raise
    except Exception as e:
        raise IOError(e)
    return res
1014154
def load(path=None):
        
        if path is None:
            path = os.path.join(os.path.join(os.path.dirname(os.path.abspath(__file__)), "data"))
            path = os.path.join(path, "compiled.pickle")
        with open(path, "rb") as file:
            return load(file)