code: def read_raw_bdf(
      input_fname,
      eog=None,
      misc=None,
      stim_channel="auto",
      exclude=(),
      infer_types=False,
      include=None,
      preload=False,
      units=None,
      encoding="utf8",
      *,
      verbose=None,
  ) -> RawEDF:
      """Reader function for BDF files.
  
      Parameters
      ----------
      input_fname : path-like
          Path to the BDF file.
      eog : list or tuple
          Names of channels or list of indices that should be designated EOG
          channels. Values should correspond to the electrodes in the file.
          Default is None.
      misc : list or tuple
          Names of channels or list of indices that should be designated MISC
          channels. Values should correspond to the electrodes in the file.
          Default is None.
      stim_channel : ``'auto'`` | str | list of str | int | list of int
          Defaults to ``'auto'``, which means that channels named ``'status'`` or
          ``'trigger'`` (case insensitive) are set to STIM. If str (or list of
          str), all channels matching the name(s) are set to STIM. If int (or
          list of ints), channels corresponding to the indices are set to STIM.
      exclude : list of str | str
          Channel names to exclude. This can help when reading data with
          different sampling rates to avoid unnecessary resampling. A str is
          interpreted as a regular expression.
      infer_types : bool
          If True, try to infer channel types from channel labels. If a channel
          label starts with a known type (such as 'EEG') followed by a space and
          a name (such as 'Fp1'), the channel type will be set accordingly, and
          the channel will be renamed to the original label without the prefix.
          For unknown prefixes, the type will be 'EEG' and the name will not be
          modified. If False, do not infer types and assume all channels are of
          type 'EEG'.
  
          .. versionadded:: 0.24.1
      include : list of str | str
          Channel names to be included. A str is interpreted as a regular
          expression. 'exclude' must be empty if include is assigned.
  
          .. versionadded:: 1.1
      %(preload)s
      %(units_edf_bdf_io)s
      %(encoding_edf)s
      %(verbose)s
  
      Returns
      -------
      raw : instance of RawEDF
          The raw instance.
          See :class:`mne.io.Raw` for documentation of attributes and methods.
  
      See Also
      --------
      mne.io.read_raw_edf : Reader function for EDF and EDF+ files.
      mne.io.read_raw_gdf : Reader function for GDF files.
      mne.io.Raw : Documentation of attributes and methods of RawEDF.
  
      Notes
      -----
      :class:`mne.io.Raw` only stores signals with matching sampling frequencies.
      Therefore, if mixed sampling frequency signals are requested, all signals
      are upsampled to the highest loaded sampling frequency. In this case, using
      preload=True is recommended, as otherwise, edge artifacts appear when
      slices of the signal are requested.
  
      Biosemi devices trigger codes are encoded in 16-bit format, whereas system
      codes (CMS in/out-of range, battery low, etc.) are coded in bits 16-23 of
      the status channel (see http://www.biosemi.com/faq/trigger_signals.htm).
      To retrieve correct event values (bits 1-16), one could do:
  
          >>> events = mne.find_events(...)  # doctest:+SKIP
          >>> events[:, 2] &= (2**16 - 1)  # doctest:+SKIP
  
      The above operation can be carried out directly in :func:`mne.find_events`
      using the ``mask`` and ``mask_type`` parameters (see
      :func:`mne.find_events` for more details).
  
      It is also possible to retrieve system codes, but no particular effort has
      been made to decode these in MNE. In case it is necessary, for instance to
      check the CMS bit, the following operation can be carried out:
  
          >>> cms_bit = 20  # doctest:+SKIP
          >>> cms_high = (events[:, 2] & (1 << cms_bit)) != 0  # doctest:+SKIP
  
      It is worth noting that in some special cases, it may be necessary to shift
      event values in order to retrieve correct event triggers. This depends on
      the triggering device used to perform the synchronization. For instance, in
      some files events need to be shifted by 8 bits:
  
          >>> events[:, 2] >>= 8  # doctest:+SKIP
  
      TAL channels called 'BDF Annotations' are parsed and extracted annotations
      are stored in raw.annotations. Use :func:`mne.events_from_annotations` to
      obtain events from these annotations.
  
      If channels named 'status' or 'trigger' are present, they are considered as
      STIM channels by default. Use func:`mne.find_events` to parse events
      encoded in such analog stim channels.
      """
      input_fname = os.path.abspath(input_fname)
      ext = os.path.splitext(input_fname)[1][1:].lower()
      if ext != "bdf":
          raise NotImplementedError(
              f"Only BDF files are supported, got {ext}."
          )
      return RawEDF(
          input_fname=input_fname,
          eog=eog,
          misc=misc,
          stim_channel=stim_channel,
          exclude=exclude,
          infer_types=infer_types,
          preload=preload,
          include=include,
          units=units,
          encoding=encoding,
          verbose=verbose,
      )
  
imports: import os
  import re
  from datetime import datetime, timedelta, timezone
  import numpy
  from scipy.interpolate import interp1d
  from ..._fiff.constants import FIFF
  from ..._fiff.meas_info import _empty_info, _unique_channel_names
  from ..._fiff.utils import _blk_read_lims, _mult_cal_one
  from ...annotations import Annotations
  from ...filter import resample
  from ...utils import _validate_type, fill_doc, logger, verbose, warn
  from ..base import BaseRaw, _get_scaling
label_desc: Use image node_id 15 for calling a global function with example usage: read_raw_bdf(input_fname, eog, misc, stim_channel, exclude, infer_types, include, preload, units, encoding) and returns: RawEDF