code: def _create_transition_filters(
      self,
      video_streams: List[str],
      audio_streams: List[str],
      process_audio: bool,
      out_video: str = "[v]",
      out_audio: str = "[a]",
  ) -> List[str]:
      if self.transition is None:
          return self._create_null_transition_filters(
              video_streams, audio_streams, process_audio
          )
  
      transition = self.transition
      effect = transition.effect.name.lower()
  
      video_durations = [
          float(get_video_info(video_path)["duration"])
          for video_path in self.video_paths
      ]
      log.info(f"Video durations = {video_durations}.")
      # There are 2 steps:
      # 1. Harmonize the timebase between clips;
      # 2. Add the transition filter.
      td = transition.duration
      concat_filters = []
      for i, name in enumerate(video_streams):
          fps_filter = f"[{i}fps]"
          concat_filters.append(
              f"{name}settb=AVTB,fps=30/1{fps_filter}"
          )
  
      if td > min(video_durations):
          raise ValueError(
              f"transition duration {td} should be smaller than video durations {min(video_durations)} "
          )
  
      prev = "[0fps]"
      cum_dur = video_durations[0]
      for i in range(1, len(video_durations) - 1):
          dur = video_durations[i]
          fps_filter = f"[{i}fps]"
          out_filter = f"[{i}m]"
          offset = cum_dur - td
          concat_filters.append(
              f"{prev}{fps_filter}xfade=transition={effect}:duration={td}:offset={offset}{out_filter}"
          )
          prev = out_filter
          cum_dur += dur - td
  
      # Special processing for the last filter to comply with out_video requirement.
      concat_filters.append(
          f"{prev}[{len(video_durations) - 1}fps]xfade=transition={effect}:duration={td}:offset={cum_dur - td}{out_video}"
      )
  
      # Concat audio filters.
      if process_audio:
          prev = audio_streams[0]
          cum_dur = video_durations[0]
          for i in range(1, len(video_durations) - 1):
              dur = video_durations[i]
              in_f = audio_streams[i]
              out_f = f"[a{i}m]"
              offset = cum_dur - td
              concat_filters.append(
                  f"{prev}{in_f}acrossfade=d={td}:c1=tri:c2=tri{out_f}"
              )
              prev = out_f
              cum_dur += dur - td
  
          concat_filters.append(
              f"{prev}[{len(video_durations) - 1}:a]acrossfade=d={td}:c1=tri:c2=tri{out_audio}"
          )
  
      return concat_filters
  
file_path: AugLy/augly/video/augmenters/ffmpeg/concat.py
imports: import logging
  from dataclasses import dataclass
  from enum import Enum
  from math import ceil
  from typing import List, Optional
  from augly.utils import pathmgr
  from augly.video.augmenters.ffmpeg.base_augmenter import BaseVidgearFFMPEGAugmenter
  from augly.video.helpers import get_video_info, has_audio_stream
  from dataclasses_json import dataclass_json
label_desc: Use image node_id 3 for calling the VideoAugmenterByConcat obj's underlying member method code with example usage: obj._create_transition_filters(video_streams, audio_streams, process_audio, out_video, out_audio) and returns: concat_filters, self