class_docstr: Reader for GAC and LAC data.
class_docstr_tok: ["Reader","for","GAC","and","LAC","data","."]
docstr: Get the dataset.
docstr_tok: ["Get","the","dataset","."]
code: def get_dataset(self, key, info):
      """Get the dataset."""
      self.read_raw_data()
      if key["name"] in ["latitude", "longitude"]:
          # Lats/lons are buffered by the reader
          if key["name"] == "latitude":
              _, data = self.reader.get_lonlat()
          else:
              data, _ = self.reader.get_lonlat()
  
          # If coordinate interpolation is disabled, only every eighth
          # pixel has a lat/lon coordinate
          xdim = "x" if self.interpolate_coords else "x_every_eighth"
          xcoords = None
      elif key["name"] in ANGLES:
          data = self._get_angle(key)
          xdim = "x" if self.interpolate_coords else "x_every_eighth"
          xcoords = None
      elif key["name"] == "qual_flags":
          data = self.reader.get_qual_flags()
          xdim = "num_flags"
          xcoords = [
              "Scan line number",
              "Fatal error flag",
              "Insufficient data for calibration",
              "Insufficient data for calibration",
              "Solar contamination of blackbody in channels 3",
              "Solar contamination of blackbody in channels 4",
              "Solar contamination of blackbody in channels 5",
          ]
      elif key["name"].upper() in self.chn_dict:
          # Read and calibrate channel data
          data = self._get_channel(key)
          xdim = "x"
          xcoords = None
      else:
          raise ValueError("Unknown dataset: {}".format(key["name"]))
  
      # Update start/end time using the actual scanline timestamps
      times = self.reader.get_times()
      self._start_time = times[0].astype(datetime)
      self._end_time = times[-1].astype(datetime)
  
      # Select user-defined scanlines and/or strip invalid coordinates
      if (
          self.start_line is not None
          or self.end_line is not None
          or self.strip_invalid_coords
      ):
          data, times = self.slice(data=data, times=times)
  
      # Create data array
      chunk_cols = data.shape[1]
      chunk_lines = int((CHUNK_SIZE**2) / chunk_cols)
      res = xr.DataArray(
          da.from_array(data, chunks=(chunk_lines, chunk_cols)),
          dims=["y", xdim],
          attrs=info,
      )
      if xcoords:
          res[xdim] = xcoords
  
      # Update dataset attributes
      self._update_attrs(res)
  
      # Add scanline acquisition times
      res["acq_time"] = ("y", times)
      res["acq_time"].attrs[
          "long_name"
      ] = "Mean scanline acquisition time"
  
      return res
  
imports: import logging
  from datetime import datetime, timedelta
  import dask.array
  import numpy
  import pygac.utils
  import xarray
  from pygac.gac_klm import GACKLMReader
  from pygac.gac_pod import GACPODReader
  from pygac.lac_klm import LACKLMReader
  from pygac.lac_pod import LACPODReader
  from satpy.readers.file_handlers import BaseFileHandler
  from satpy.utils import get_legacy_chunk_size
label_desc: Use image node_id 3 for calling the GACLACFile obj's underlying member method code with example usage: obj.get_dataset(key, info) and returns: res