text: """Behavioural Analysis Controller Module"""
  __docformat__ = "numpy"
  
  import argparse
  from typing import List
  from datetime import datetime
  
  from gamestonk_terminal import feature_flags as gtff
  from gamestonk_terminal.helper_funcs import get_flair
  from gamestonk_terminal.menu import session
  from gamestonk_terminal.behavioural_analysis import (
      google_view,
      reddit_view,
      stocktwits_view,
      finbrain_view,
  )
  from prompt_toolkit.completion import NestedCompleter
  
  
  class BehaviouralAnalysisController:
      """Behavioural Analysis Controller class"""
  
      # Command choices
      CHOICES = [
          "help",
          "q",
          "quit",
          "watchlist",
          "spac",
          "spac_c",
          "wsb",
          "popular",
          "bullbear",
          "messages",
          "trending",
          "stalker",
          "infer",
          "sentiment",
          "mentions",
          "regions",
          "queries",
          "rise",
          "finbrain",
      ]
  
      def __init__(self, ticker: str, start: datetime):
          """Constructor"""
          self.ticker = ticker
          self.start = start
          self.ba_parser = argparse.ArgumentParser(add_help=False, prog="ba")
          self.ba_parser.add_argument(
              "cmd",
              choices=self.CHOICES,
          )
  
      @staticmethod
      def print_help():
          """Print help"""
  
          print("\nBehavioural Analysis:")
          print("   help          show this behavioural analysis menu again")
          print("   q             quit this menu, and shows back to main menu")
          print("   quit          quit to abandon program")
          print("")
          print("   finbrain      sentiment from 15+ major news headlines")
          print("")
          print("Reddit:")
          print(
              "   wsb           show what WSB gang is up to in subreddit wallstreetbets"
          )
          print("   watchlist     show other users watchlist")
          print("   popular       show popular tickers")
          print(
              "   spac_c        show other users spacs announcements from subreddit SPACs community"
          )
          print("   spac          show other users spacs announcements from other subs")
          print("")
          print("Stocktwits:")
          print(
              "   bullbear      estimate quick sentiment from last 30 messages on board"
          )
          print("   messages      output up to the 30 last messages on the board")
          print("   trending      trending stocks")
          print("   stalker       stalk stocktwits user's last messages")
          print("")
          print("Twitter:")
          print("   infer         infer about stock's sentiment from latest tweets")
          print("   sentiment     in-depth sentiment prediction from tweets over time")
          print("")
          print("Google:")
          print("   mentions      interest over time based on stock's mentions")
          print("   regions       regions that show highest interest in stock")
          print("   queries       top related queries with this stock")
          print("   rise          top rising related queries with stock")
          print("")
  
      def switch(self, an_input: str):
          """Process and dispatch input
  
          Returns
          -------
          True, False or None
              False - quit the menu
              True - quit the program
              None - continue in the menu
          """
          (known_args, other_args) = self.ba_parser.parse_known_args(an_input.split())
  
          return getattr(
              self, "call_" + known_args.cmd, lambda: "Command not recognized!"
          )(other_args)
  
      def call_help(self, _):
          """Process Help command"""
          self.print_help()
  
      def call_q(self, _):
          """Process Q command - quit the menu"""
          return False
  
      def call_quit(self, _):
          """Process Quit command - quit the program"""
          return True
  
      def call_watchlist(self, other_args: List[str]):
          """Process watchlist command"""
          reddit_view.watchlist(other_args)
  
      def call_spac(self, other_args: List[str]):
          """Process spac command"""
          reddit_view.spac(other_args)
  
      def call_spac_c(self, other_args: List[str]):
          """Process spac_c command"""
          reddit_view.spac_community(other_args)
  
      def call_wsb(self, other_args: List[str]):
          """Process wsb command"""
          reddit_view.wsb_community(other_args)
  
      def call_popular(self, other_args: List[str]):
          """Process popular command"""
          reddit_view.popular_tickers(other_args)
  
      def call_bullbear(self, other_args: List[str]):
          """Process bullbear command"""
          stocktwits_view.bullbear(other_args, self.ticker)
  
      def call_messages(self, other_args: List[str]):
          """Process messages command"""
          stocktwits_view.messages(other_args, self.ticker)
  
      def call_trending(self, other_args: List[str]):
          """Process trending command"""
          stocktwits_view.trending(other_args)
  
      def call_stalker(self, other_args: List[str]):
          """Process stalker command"""
          stocktwits_view.stalker(other_args)
  
      def call_mentions(self, other_args: List[str]):
          """Process mentions command"""
          google_view.mentions(other_args, self.ticker, self.start)
  
      def call_regions(self, other_args: List[str]):
          """Process regions command"""
          google_view.regions(other_args, self.ticker)
  
      def call_queries(self, other_args: List[str]):
          """Process queries command"""
          google_view.queries(other_args, self.ticker)
  
      def call_rise(self, other_args: List[str]):
          """Process rise command"""
          google_view.rise(other_args, self.ticker)
  
      def call_infer(self, other_args: List[str]):
          """Process infer command"""
          if not gtff.ENABLE_PREDICT:
              print("Predict is not enabled in feature_flags.py")
              print("Twitter inference menu is disabled", "\n")
              return
  
          try:
              # pylint: disable=import-outside-toplevel
              from gamestonk_terminal.behavioural_analysis import twitter_view
          except ModuleNotFoundError as e:
              print("Optional packages need to be installed")
              print(e, "\n")
              return
          except Exception as e:
              print(e, "\n")
              return
  
          twitter_view.inference(other_args, self.ticker)
  
      def call_sentiment(self, other_args: List[str]):
          """Process sentiment command"""
          if not gtff.ENABLE_PREDICT:
              print("Predict is not enabled in feature_flags.py")
              print("Twitter inference menu is disabled", "\n")
              return
  
          try:
              # pylint: disable=import-outside-toplevel
              from gamestonk_terminal.behavioural_analysis import twitter_view
          except ModuleNotFoundError as e:
              print("Optional packages need to be installed")
              print(e, "\n")
              return
          except Exception as e:
              print(e, "\n")
              return
  
          twitter_view.sentiment(other_args, self.ticker)
  
      def call_finbrain(self, other_args: List[str]):
          """Process finbrain command"""
          finbrain_view.sentiment_analysis(other_args, self.ticker)
  
  
  def menu(ticker: str, start: datetime):
      """Behavioural Analysis Menu"""
  
      ba_controller = BehaviouralAnalysisController(ticker, start)
      ba_controller.call_help(None)
  
      while True:
          # Get input command from user
          if session and gtff.USE_PROMPT_TOOLKIT:
              completer = NestedCompleter.from_nested_dict(
                  {c: None for c in ba_controller.CHOICES}
              )
              an_input = session.prompt(
                  f"{get_flair()} (ba)> ",
                  completer=completer,
              )
          else:
              an_input = input(f"{get_flair()} (ba)> ")
  
          try:
              process_input = ba_controller.switch(an_input)
  
              if process_input is not None:
                  return process_input
  
          except SystemExit:
              print("The command selected doesn't exist\n")
              continue
  