code: def check_seasonality(
      ts: TimeSeries,
      m: Optional[int] = None,
      max_lag: int = 24,
      alpha: float = 0.05,
  ):
      """
      Checks whether the TimeSeries `ts` is seasonal with period `m` or not.
  
      If `m` is None, we work under the assumption that there is a unique seasonality period, which is inferred
      from the Auto-correlation Function (ACF).
  
      Parameters
      ----------
      ts
          The time series to check for seasonality.
      m
          The seasonality period to check.
      max_lag
          The maximal lag allowed in the ACF.
      alpha
          The desired confidence level (default 5%).
  
      Returns
      -------
      Tuple[bool, int]
          A tuple `(season, m)`, where season is a boolean indicating whether the series has seasonality or not
          and `m` is the seasonality period.
      """
  
      ts._assert_univariate()
  
      if m is not None and (m < 2 or not isinstance(m, int)):
          raise_log(
              ValueError("m must be an integer greater than 1."), logger
          )
  
      if m is not None and m > max_lag:
          raise_log(
              ValueError("max_lag must be greater than or equal to m."),
              logger,
          )
  
      n_unique = np.unique(ts.values()).shape[0]
  
      if n_unique == 1:  # Check for non-constant TimeSeries
          return False, 0
  
      r = acf(
          ts.values(), nlags=max_lag, fft=False
      )  # In case user wants to check for seasonality higher than 24 steps.
  
      # Finds local maxima of Auto-Correlation Function
      candidates = argrelmax(r)[0]
  
      if len(candidates) == 0:
          return False, 0
  
      if m is not None:
          # Check for local maximum when m is user defined.
          test = m not in candidates
  
          if test:
              return False, m
  
          candidates = [m]
  
      # Remove r[0], the auto-correlation at lag order 0, that introduces bias.
      r = r[1:]
  
      # The non-adjusted upper limit of the significance interval.
      band_upper = r.mean() + norm.ppf(1 - alpha / 2) * r.var()
  
      # Significance test, stops at first admissible value. The two '-1' below
      # compensate for the index change due to the restriction of the original r to r[1:].
      for candidate in candidates:
          stat = _bartlett_formula(r, candidate - 1, len(ts))
          if r[candidate - 1] > stat * band_upper:
              return True, candidate
      return False, 0
  
imports: import math
  from typing import List, Optional, Sequence, Tuple, Union
  import matplotlib.pyplot
  import numpy
  from scipy.signal import argrelmax
  from scipy.stats import norm
  from statsmodels.tsa.seasonal import MSTL, STL, seasonal_decompose
  from statsmodels.tsa.stattools import acf, adfuller, grangercausalitytests, kpss, pacf
  from darts import TimeSeries
  from darts.logging import get_logger, raise_if, raise_if_not, raise_log
  from .missing_values import fill_missing_values
  from .utils import ModelMode, SeasonalityMode
label_desc: Use image node_id 1 for calling a global function with example usage: check_seasonality(ts, m, max_lag, alpha) and returns: False,  int, False,  int, False,  int, False,  m, True,  candidate