docs: def order(self, meta=None, meta_ascending=None, meta_top=None, meta_k=None,
                regs=None, regs_ascending=None, region_top=None, region_k=None):
          """
          *Wrapper of* ``ORDER``
  
          The ORDER operator is used to order either samples, sample regions, or both,
          in a dataset according to a set of metadata and/or region attributes, and/or 
          region coordinates. The number of samples and their regions in the output dataset 
          is as in the input dataset, as well as their metadata and region attributes 
          and values, but a new ordering metadata and/or region attribute is added with 
          the sample or region ordering value, respectively. 
          
          :param meta: list of metadata attributes
          :param meta_ascending: list of boolean values (True = ascending, False = descending)
          :param meta_top: "top", "topq" or "topp" or None
          :param meta_k: a number specifying how many results to be retained
          :param regs: list of region attributes
          :param regs_ascending: list of boolean values (True = ascending, False = descending)
          :param region_top: "top", "topq" or "topp" or None
          :param region_k: a number specifying how many results to be retained
          :return: a new GMQLDataset
  
  
          Example of usage. We order Example_Dataset_1 metadata by ascending `antibody` and descending `antibody_class`
          keeping only the first sample. We also order the resulting regions based on the `score` field in descending
          order, keeping only the first one also in this case::
  
              import gmql as gl
  
              d1 = gl.get_example_dataset("Example_Dataset_1")
  
              result = d1.order(meta=["antibody", "antibody_targetClass"],
                                meta_ascending=[True, False], meta_top="top", meta_k=1,
                                regs=['score'], regs_ascending=[False],
                                region_top="top", region_k=1)
          """
          meta_exists = False
          meta_len = 0
          if isinstance(meta, list) and \
              all([isinstance(x, str) for x in meta]):
              meta_exists = True
              meta_len = len(meta)
              meta = Some(meta)
          elif meta is None:
              meta = none()
          else:
              raise TypeError("meta must be a list of strings. "
                              "{} was provided".format(type(meta)))
  
          if isinstance(meta_ascending, list) and \
              all([isinstance(x, bool) for x in meta_ascending]) and \
              meta_exists and meta_len == len(meta_ascending):
              meta_ascending = Some(meta_ascending)
          elif meta_ascending is None:
              if meta_exists:
                  # by default meta_ascending is all True
                  meta_ascending = Some([True for _ in range(meta_len)])
              else:
                  meta_ascending = none()
          else:
              raise TypeError("meta ascending must be a list of booleans having the same size "
                              "of meta. {} was provided".format(type(meta_ascending)))
  
          regs_exists = False
          regs_len = 0
          if isinstance(regs, list) and \
                  all([isinstance(x, str) for x in regs]):
              regs_exists = True
              regs_len = len(regs)
              regs = Some(regs)
          elif regs is None:
              regs = none()
          else:
              raise TypeError("regs must be a list of strings. "
                              "{} was provided".format(type(regs)))
  
          if isinstance(regs_ascending, list) and \
              all([isinstance(x, bool) for x in regs_ascending]) and \
                  regs_exists and regs_len == len(regs_ascending):
              regs_ascending = Some(regs_ascending)
          elif regs_ascending is None:
              if regs_exists:
                  # by default regs_ascending is all True
                  regs_ascending = Some([True for _ in range(regs_len)])
              else:
                  regs_ascending = none()
          else:
              raise TypeError("meta regs_ascending must be a list of booleans having the same size "
                              "of regs. {} was provided".format(type(regs_ascending)))
  
          meta_top_exists = False
          if isinstance(meta_top, str):
              if meta_exists:
                  meta_top = Some(meta_top)
                  meta_top_exists = True
              else:
                  raise ValueError("meta_top must be defined only when meta is defined")
          elif meta_top is None:
              meta_top = none()
          else:
              raise TypeError("meta_top must be a string. {} was provided".format(type(meta_top)))
  
          if isinstance(meta_k, int) and \
                  meta_top_exists:
              meta_k = Some(meta_k)
          elif meta_k is None and \
                  not meta_top_exists:
              meta_k = none()
          else:
              raise TypeError("meta_k must be an integer and should be provided together with a "
                              "value of meta_top. {} was provided".format(type(meta_k)))
  
          region_top_exists = False
          if isinstance(region_top, str):
              if regs_exists:
                  region_top = Some(region_top)
                  region_top_exists = True
              else:
                  raise ValueError("region_top must be defined only when regs is defined")
          elif region_top is None:
              region_top = none()
          else:
              raise TypeError("region_top must be a string. {} was provided".format(type(region_top)))
  
          if isinstance(region_k, int) and \
                  region_top_exists:
              region_k = Some(region_k)
          elif region_k is None and \
                  not region_top_exists:
              region_k = none()
          else:
              raise TypeError("region_k must be an integer and should be provided together with a "
                              "value of region_top. {} was provided".format(type(region_k)))
  
          new_index = self.opmng.order(self.__index, meta, meta_ascending, meta_top, meta_k,
                                       regs, regs_ascending, region_top, region_k)
          return GMQLDataset(index=new_index, location=self.location,
                             local_sources=self._local_sources,
                             remote_sources=self._remote_sources,
                             meta_profile=self.meta_profile)