code: def get_google_intraday_data(symbol, lookback_period, fractal):
      r"""Get Google Finance intraday data.
  
      We get intraday data from the Google Finance API, even though
      it is not officially supported. You can retrieve a maximum of
      50 days of history, so you may want to build your own database
      for more extensive backtesting.
  
      Parameters
      ----------
      symbol : str
          A valid stock symbol.
      lookback_period : int
          The number of days of intraday data to retrieve, capped at 50.
      fractal : str
          The intraday frequency, e.g., "5m" for 5-minute data.
  
      Returns
      -------
      df : pandas.DataFrame
          The dataframe containing the intraday data.
  
      """
  
      # Google requires upper-case symbol, otherwise not found
      symbol = symbol.upper()
      # Initialize data frame
      df = pd.DataFrame()
      # Convert fractal to interval
      interval = 60 * int(re.findall("\d+", fractal)[0])
      # Google has a 50-day limit
      max_days = 50
      if lookback_period > max_days:
          lookback_period = max_days
      # Set Google data constants
      toffset = 7
      line_length = 6
      # Make the request to Google
      base_url = "https://finance.google.com/finance/getprices?q={}&i={}&p={}d&f=d,o,h,l,c,v"
      url = base_url.format(symbol, interval, lookback_period)
      response = requests.get(url)
      # Process the response
      text = response.text.split("\n")
      records = []
      for line in text[toffset:]:
          items = line.split(",")
          if len(items) == line_length:
              dt_item = items[0]
              close_item = items[1]
              high_item = items[2]
              low_item = items[3]
              open_item = items[4]
              volume_item = items[5]
              if dt_item[0] == "a":
                  day_item = float(dt_item[1:])
                  offset = 0
              else:
                  offset = float(dt_item)
              dt = datetime.fromtimestamp(
                  day_item + (interval * offset)
              )
              dt = pd.to_datetime(dt)
              dt_date = dt.strftime("%Y-%m-%d")
              dt_time = dt.strftime("%H:%M:%S")
              record = (
                  dt_date,
                  dt_time,
                  open_item,
                  high_item,
                  low_item,
                  close_item,
                  volume_item,
              )
              records.append(record)
      # Create data frame
      cols = ["date", "time", "open", "high", "low", "close", "volume"]
      df = pd.DataFrame.from_records(records, columns=cols)
      # Return the dataframe
      return df
  
imports: from alphapy.frame import Frame
  from alphapy.frame import frame_name
  from alphapy.frame import read_frame
  from alphapy.globals import ModelType
  from alphapy.globals import Partition, datasets
  from alphapy.globals import PSEP, SSEP, USEP
  from alphapy.globals import SamplingMethod
  from alphapy.globals import WILDCARD
  from alphapy.space import Space
  import arrow
  from datetime import datetime
  from datetime import timedelta
  from iexfinance.stocks import get_historical_data
  from iexfinance.stocks import get_historical_intraday
  from imblearn.combine import SMOTEENN
  from imblearn.combine import SMOTETomek
  import imblearn.ensemble
  from imblearn.over_sampling import RandomOverSampler
  from imblearn.over_sampling import SMOTE
  from imblearn.under_sampling import ClusterCentroids
  from imblearn.under_sampling import CondensedNearestNeighbour
  from imblearn.under_sampling import EditedNearestNeighbours
  from imblearn.under_sampling import InstanceHardnessThreshold
  from imblearn.under_sampling import NearMiss
  from imblearn.under_sampling import NeighbourhoodCleaningRule
  from imblearn.under_sampling import OneSidedSelection
  from imblearn.under_sampling import RandomUnderSampler
  from imblearn.under_sampling import RepeatedEditedNearestNeighbours
  from imblearn.under_sampling import TomekLinks
  import logging
  import math
  import numpy
  import os
  import pandas
  import pandas_datareader.data
  import re
  import requests
  from scipy import sparse
  from sklearn.preprocessing import LabelEncoder
  import sys
label_desc: Use image node_id 6 for calling a global function with example usage: get_google_intraday_data(symbol, lookback_period, fractal) and returns: df