code: def dataset_overview(
      train_data: Optional[pd.DataFrame] = None,
      test_data: Optional[pd.DataFrame] = None,
      val_data: Optional[pd.DataFrame] = None,
      label: Optional[str] = None,
      state: Union[None, dict, AnalysisState] = None,
      return_state: bool = False,
      sample: Union[None, int, float] = DEFAULT_SAMPLE_SIZE,
      fig_args: Optional[Dict[str, Dict[str, Any]]] = None,
      chart_args: Optional[Dict[str, Dict[str, Any]]] = None,
  ):
      """
      Shortcut to perform high-level datasets summary overview (counts, frequencies, missing statistics, types info).
  
      Supported `fig_args`/`chart_args` keys:
          - `feature_distance.<property>` - feature distance dendrogram chart
          - `chart.<variable>.<property>` - near-duplicate groups visualizations chart. If chart is labeled as a relationship <A>/<B>, then <variable> is <B>
  
      Parameters
      ----------
      train_data: Optional[DataFrame], default = None
          training dataset
      test_data: Optional[DataFrame], default = None
          test dataset
      val_data: Optional[DataFrame], default = None
          validation dataset
      label: : Optional[str], default = None
          target variable
      state: Union[None, dict, AnalysisState], default = None
          pass prior state if necessary; the object will be updated during `anlz_facets` `fit` call.
      return_state: bool, default = False
          return state if `True`
      sample: Union[None, int, float], default = 10000
          sample size; if `int`, then row number is used;
          `float` must be between 0.0 and 1.0 and represents fraction of dataset to sample;
          `None` means no sampling
          See also :func:`autogluon.eda.analysis.dataset.Sampler`
      fig_args: Optional[Dict[str, Any]], default = None,
          figures args for visualizations; key == component; value = dict of kwargs for component figure
      chart_args: Optional[Dict[str, Any]], default = None,
          figures args for visualizations; key == component; value = dict of kwargs for component chart
  
      Examples
      --------
      >>> import autogluon.eda.analysis as eda
      >>>
      >>> auto.dataset_overview(
      >>>     train_data=df_train, test_data=df_test, label=target_col,
      >>>     chart_args={'feature_distance.orientation': 'left'},
      >>>     fig_args={'feature_distance.figsize': (6,6)},
      >>> )
  
      See Also
      --------
      :py:class:`~autogluon.eda.analysis.dataset.DatasetSummary`
      :py:class:`~autogluon.eda.analysis.dataset.RawTypesAnalysis`
      :py:class:`~autogluon.eda.analysis.dataset.SpecialTypesAnalysis`
      :py:class:`~autogluon.eda.analysis.missing.MissingValuesAnalysis`
      :py:class:`~autogluon.eda.visualization.dataset.DatasetStatistics`
      :py:class:`~autogluon.eda.visualization.dataset.DatasetTypeMismatch`
  
      """
  
      fig_args = expand_nested_args_into_nested_maps(
          get_empty_dict_if_none(fig_args)
      )
      chart_args = expand_nested_args_into_nested_maps(
          get_empty_dict_if_none(chart_args)
      )
  
      state = analyze(
          train_data=train_data,
          test_data=test_data,
          val_data=val_data,
          label=label,
          sample=sample,
          state=state,
          return_state=True,
          anlz_facets=[
              DatasetSummary(),
              MissingValuesAnalysis(),
              RawTypesAnalysis(),
              VariableTypeAnalysis(),
              SpecialTypesAnalysis(),
              ApplyFeatureGenerator(
                  category_to_numbers=True,
                  children=[FeatureDistanceAnalysis()],
              ),
          ],
          viz_facets=[
              DatasetStatistics(headers=True),
              DatasetTypeMismatch(headers=True),
              MarkdownSectionComponent("### Feature Distance"),
              FeatureDistanceAnalysisVisualization(
                  fig_args=fig_args.get("feature_distance", {}),
                  **chart_args.get("feature_distance", {}),
              ),
          ],
      )
  
      # Groups analysis
      distance = state.feature_distance  # type: ignore # state is always present
      if len(distance.near_duplicates) > 0:  # type: ignore # state is always present
          for group in distance.near_duplicates:
              nodes = group["nodes"]
  
              interactions: List[AbstractVisualization] = []
              for n in nodes[1:]:
                  if state.variable_type.train_data[n] != "category":  # type: ignore
                      interactions.append(
                          MarkdownSectionComponent(
                              f"Feature interaction between `{nodes[0]}`/`{n}`"
                          )
                      )
                      interactions.append(
                          FeatureInteractionVisualization(
                              key=f"{nodes[0]}:{n}",
                              fig_args=fig_args.get("chart", {}).get(
                                  n, {}
                              ),
                              **chart_args.get("chart", {}).get(n, {}),
                          )
                      )
  
              analyze(
                  train_data=train_data,
                  state=state,
                  anlz_facets=[
                      FeatureInteraction(
                          key=f"{nodes[0]}:{n}", x=nodes[0], y=n
                      )
                      for n in nodes[1:]
                  ],
                  viz_facets=[
                      *interactions,
                  ],
              )
  
      return state if return_state else None
  
imports: import logging
  from typing import Any, Dict, List, Optional, Tuple, Union
  import pandas
  from autogluon.common.utils.log_utils import verbosity2loglevel
  from autogluon.features import CategoryFeatureGenerator
  from autogluon.tabular import TabularPredictor
  from ..None import AnalysisState
  from ..analysis import AnomalyDetectorAnalysis, ApplyFeatureGenerator, AutoGluonModelEvaluator, AutoGluonModelQuickFit, Correlation, DistributionFit, FeatureInteraction, MissingValuesAnalysis, ProblemTypeControl, ShapAnalysis, TrainValidationSplit, XShiftDetector
  from ..analysis.base import AbstractAnalysis, BaseAnalysis, SaveArgsToState
  from ..analysis.dataset import DatasetSummary, LabelInsightsAnalysis, RawTypesAnalysis, Sampler, SpecialTypesAnalysis, VariableTypeAnalysis
  from ..analysis.interaction import FeatureDistanceAnalysis
  from ..state import is_key_present_in_state
  from ..utils.common import expand_nested_args_into_nested_maps, get_empty_dict_if_none
  from ..utils.defaults import QuickFitDefaults
  from ..visualization import AnomalyScoresVisualization, ConfusionMatrix, CorrelationVisualization, DatasetStatistics, DatasetTypeMismatch, ExplainForcePlot, ExplainWaterfallPlot, FeatureImportance, FeatureInteractionVisualization, LabelInsightsVisualization, MarkdownSectionComponent, MissingValues, ModelLeaderboard, PropertyRendererComponent, RegressionEvaluation, XShiftSummary
  from ..visualization.base import AbstractVisualization
  from ..visualization.interaction import FeatureDistanceAnalysisVisualization, PDPInteractions
  from ..visualization.layouts import SimpleVerticalLinearLayout
label_desc: Use image node_id 5 for calling a global function with example usage: dataset_overview(train_data, test_data, val_data, label, state, return_state, sample, fig_args, chart_args) and returns: unknown