class_docstr: Base class used as parent for the concrete LI reader classes.
class_docstr_tok: ["Base","class","used","as","parent","for","the","concrete","LI","reader","classes","."]
docstr: Initialize LINCFileHandler.
docstr_tok: ["Initialize","LINCFileHandler","."]
code: def __init__(
      self, filename, filename_info, filetype_info, cache_handle=True
  ):
      """Initialize LINCFileHandler."""
      super().__init__(
          filename,
          filename_info,
          filetype_info,
          cache_var_size=10000,
          cache_handle=cache_handle,
      )
  
      # decode_times should be disabled for xr.open_dataset access (cache_handle=False):
      # Note: the default dict assignment is need to avoid error when using the fake
      # netcdf4 file handler in mock unit tests:
      self._xarray_kwargs = getattr(self, "_xarray_kwargs", {})
      self._xarray_kwargs["decode_times"] = False
      self._xarray_kwargs["mask_and_scale"] = False
  
      # Processing level that should be set by derived classes.
      self.processing_level = filetype_info.get(
          "processing_level", "L0"
      )
  
      # This class will only provide support for the LI sensor:
      self.sensors = {"li"}
  
      # Set of dataset names explicitly provided by this file handler:
      # This set is required to filter the retrieval of datasets later in the
      # get_dataset() method, for instance when building a Scene from multiple
      # different product files (example: 1 L1B BCK file + 1 L1B LE file):
      # the dataset loading mechanism will still request from the LE specific
      # file handler if it can load a 'timestamp_vis_08_north_sector' dataset
      # for instance.
      # And when concatenating multiple BCK files into a single scene, usually
      # only one of the file handler will be able to load a specific timestamp.
      # => We could recompute the availability of a dataset from the provided
      # ds_info in get_dataset(), but it seems a better/easier solution to just
      # cache the set of available dataset names as generated in 'available_datasets()'
      # directly here:
      self.provided_datasets = set()
  
      self.ds_desc = filetype_info["file_desc"]
      # Store the extra infos available on specific variables:
      # Write the correct product type here:
      self.product_type = self.ds_desc["product_type"]
      logger.debug("Product type is: %s", self.product_type)
  
      self.variable_transforms = self.ds_desc.get(
          "variable_transforms", {}
      )
  
      # Store the pattern for the default swath coordinates:
      # Note that we should always have this swath coordinates entry now:
      self.swath_coordinates = self.ds_desc.get("swath_coordinates", {})
      patterns = self.swath_coordinates.get("variable_patterns", [])
      self.swath_coordinates["patterns"] = [
          re.compile(pstr) for pstr in patterns
      ]
  
      # check if the current product is in an accumulation grid
      self.prod_in_accumulation_grid = (
          self.is_prod_in_accumulation_grid()
      )
  
      # list of paths where we should be looking for data when trying to retrieve
      # "measured variables" from the netcdf file attached to this file handler.
      self.search_paths = None
  
      # Storage for the registered datasets provided in this file handler: will only be
      # initialized once in `register_available_datasets()`
      self.dataset_infos = None
  
      # Storage for the current ds_infos in use in a call to get_dataset()
      self.current_ds_info = None
  
      # Ordered list of transform operations supported in this file handler:
      # those transforms are applied if requested in the 'apply_transforms' method below
      self.transform_names = [
          "use_rescaling",
          "seconds_to_timedelta",
          "milliseconds_to_timedelta",
          "seconds_to_datetime",
          "broadcast_to",
          "accumulate_index_offset",
      ]
  
      # store internal variables
      self.internal_variables = {}
  
      # We register all the available datasets on creation:
      self.register_available_datasets()
  
imports: import logging
  import re
  import dask.array
  import netCDF4
  import numpy
  import xarray
  from pyproj import Proj
  from satpy.readers.netcdf_utils import NetCDF4FileHandler
label_desc: Use image node_id 1 to create a new LINCFileHandler object from inherited base classes: NetCDF4FileHandler with example: obj = LINCFileHandler(filename, filename_info, filetype_info, cache_handle)