docs: def load_from_path(local_path=None, parser=None,  all_load=False):
      """ Loads the data from a local path into a GMQLDataset.
      The loading of the files is "lazy", which means that the files are loaded only when the
      user does a materialization (see :func:`~gmql.dataset.GMQLDataset.GMQLDataset.materialize` ).
      The user can force the materialization of the data (maybe for an initial data exploration on
      only the metadata) by setting the :attr:`~.reg_load` (load in memory the region data),
      :attr:`~.meta_load` (load in memory the metadata) or :attr:`~.all_load` (load both region and
      meta data in memory). If the user specifies this final parameter as True, a
      :class:`~gmql.dataset.GDataframe.GDataframe` is returned, otherwise a
      :class:`~gmql.dataset.GMQLDataset.GMQLDataset` is returned
      
      :param local_path: local path of the dataset
      :param parser: the parser to be used for reading the data
      :param all_load: if set to True, both region and meta data are loaded in memory and an 
                       instance of GDataframe is returned
      :return: A new GMQLDataset or a GDataframe
      """
  
      from .. import GDataframe
      from .. import GMQLDataset
      pmg = get_python_manager()
  
      local_path = preprocess_path(local_path)
  
      if all_load:
          # load directly the metadata for exploration
          meta = MetaLoaderFile.load_meta_from_path(local_path)
          if isinstance(parser, RegionParser):
              # region data
              regs = RegLoaderFile.load_reg_from_path(local_path, parser)
          else:
              regs = RegLoaderFile.load_reg_from_path(local_path)
  
          return GDataframe.GDataframe(regs=regs, meta=meta)
      else:
          from ...settings import is_metaprofiling_enabled
          if is_metaprofiling_enabled():
              meta_profile = create_metadata_profile(local_path)
          else:
              meta_profile = None
  
          if parser is None:
              # find the parser
              parser = RegLoaderFile.get_parser(local_path)
          elif not isinstance(parser, RegionParser):
              raise ValueError("parser must be RegionParser. {} was provided".format(type(parser)))
  
          source_table = get_source_table()
          id = source_table.search_source(local=local_path)
          if id is None:
              id = source_table.add_source(local=local_path, parser=parser)
          local_sources = [id]
  
          index = pmg.read_dataset(str(id), parser.get_gmql_parser())
          return GMQLDataset.GMQLDataset(index=index, parser=parser,
                                         location="local", path_or_name=local_path,
                                         local_sources=local_sources,
                                         meta_profile=meta_profile)