text: """Oanda View"""
  __docformat__ = "numpy"
  
  import argparse
  from datetime import datetime
  from typing import List
  
  import matplotlib.pyplot as plt
  import matplotlib.ticker as mticker
  import mplfinance as mpf
  import pandas as pd
  import pandas_ta as ta
  import seaborn as sns
  from oandapyV20 import API
  from oandapyV20.endpoints import (
      accounts,
      forexlabs,
      instruments,
      orders,
      positions,
      pricing,
      trades,
  )
  from oandapyV20.exceptions import V20Error
  
  from gamestonk_terminal import config_plot as cfgPlot
  from gamestonk_terminal import config_terminal as cfg
  from gamestonk_terminal import feature_flags as gtff
  from gamestonk_terminal.helper_funcs import (
      check_non_negative,
      parse_known_args_and_warn,
      plot_autoscale,
  )
  
  client = API(access_token=cfg.OANDA_TOKEN, environment=cfg.OANDA_ACCOUNT_TYPE)
  account = cfg.OANDA_ACCOUNT
  
  
  def get_fx_price(accountID, instrument, other_args: List[str]):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="price",
          description="Get price for selected instrument.",
      )
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
  
      try:
          parameters = {"instruments": instrument}
          request = pricing.PricingInfo(accountID=accountID, params=parameters)
          response = client.request(request)
          bid = response["prices"][0]["bids"][0]["price"]
          ask = response["prices"][0]["asks"][0]["price"]
          print(instrument + " Bid: " + bid)
          print(instrument + " Ask: " + ask)
          print("")
  
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["errorMessage"], "\n")
  
  
  def get_account_summary(accountID, other_args: List[str]):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="summary",
          description="Print some information about your account.",
      )
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
  
      try:
          request = accounts.AccountSummary(accountID=accountID)
          response = client.request(request)
  
          df_summary = pd.DataFrame(
              [
                  {"Type": "Balance", "Value": response["account"]["balance"]},
                  {"Type": "NAV", "Value": response["account"]["NAV"]},
                  {
                      "Type": "Unrealized P/L",
                      "Value": response["account"]["unrealizedPL"],
                  },
                  {"Type": "Total P/L", "Value": response["account"]["pl"]},
                  {
                      "Type": "Open Trade Count",
                      "Value": response["account"]["openTradeCount"],
                  },
                  {
                      "Type": "Margin Available",
                      "Value": response["account"]["marginAvailable"],
                  },
                  {"Type": "Margin Used", "Value": response["account"]["marginUsed"]},
                  {
                      "Type": "Margin Closeout",
                      "Value": response["account"]["marginCloseoutNAV"],
                  },
                  {
                      "Type": "Margin Closeout Percent",
                      "Value": response["account"]["marginCloseoutPercent"],
                  },
                  {
                      "Type": "Margin Closeout Position Value",
                      "Value": response["account"]["marginCloseoutPositionValue"],
                  },
              ]
          )
  
          print(df_summary.to_string(index=False, header=False))
  
          print("")
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["errorMessage"], "\n")
  
  
  def list_orders(accountID, other_args: List[str]):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="list",
          description="List order history",
      )
      parser.add_argument(
          "-s",
          "--state",
          dest="state",
          action="store",
          default="ALL",
          required=False,
          help="Select state for order list. ",
      )
      parser.add_argument(
          "-c",
          "--count",
          dest="count",
          action="store",
          default=20,
          required=False,
          help="the number of orders to retrieve ",
      )
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
  
      parameters = {}
      parameters["state"] = ns_parser.state.upper()
      parameters["count"] = ns_parser.count
  
      try:
          request = orders.OrderList(accountID, parameters)
          response = client.request(request)
  
          df = pd.DataFrame.from_dict(response["orders"])
          df = df[["id", "instrument", "units", "price", "state", "type"]]
          print(df)
          print("")
  
      except KeyError:
          print("No orders were found\n")
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["errorMessage"], "\n")
  
  
  def get_order_book(instrument, other_args):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="orderbook",
          description="Plot the orderbook for the instrument if Oanda provides one.",
      )
  
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
      parameters = {"bucketWidth": "1"}
      try:
          instrument = format_instrument(instrument, "_")
          request = instruments.InstrumentsOrderBook(
              instrument=instrument, params=parameters
          )
          response = client.request(request)
          df = pd.DataFrame.from_dict(response["orderBook"]["buckets"])
          pd.set_option("display.max_rows", None)
          df = df.take(range(527, 727, 1))
          book_plot(df, instrument, "Order Book")
          print("")
  
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["errorMessage"], "\n")
  
  
  def get_position_book(instrument, other_args):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="positionbook",
          description="Plot the positionbook for the instrument if Oanda provides one.",
      )
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
  
      try:
          instrument = format_instrument(instrument, "_")
          request = instruments.InstrumentsPositionBook(instrument=instrument)
          response = client.request(request)
          df = pd.DataFrame.from_dict(response["positionBook"]["buckets"])
          pd.set_option("display.max_rows", None)
          df = df.take(range(219, 415, 1))
          book_plot(df, instrument, "Position Book")
          print("")
  
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["errorMessage"], "\n")
  
  
  def create_order(accountID, instrument, other_args: List[str]):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="order",
          description="Create order",
      )
      parser.add_argument(
          "-u",
          "--unit",
          dest="units",
          action="store",
          type=int,
          default=0,
          required=True,
          help="The number of units to place in the order request. Positive for "
          + "a long position and negative for a short position ",
      )
      parser.add_argument(
          "-p",
          "--price",
          dest="price",
          action="store",
          type=check_non_negative,
          required=True,
          help="The price to set for the limit order. ",
      )
  
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
      if "JPY" in instrument or "THB" in instrument or "HUF" in instrument:
          ns_parser.price = round(ns_parser.price, 3)
      else:
          ns_parser.price = round(ns_parser.price, 5)
  
      data = {
          "order": {
              "price": ns_parser.price,
              "instrument": instrument,
              "units": ns_parser.units,
              "type": "LIMIT",
              "timeInForce": "GTC",
              "positionFill": "DEFAULT",
          }
      }
      try:
          request = orders.OrderCreate(accountID, data)
          response = client.request(request)
          order_data = []
          order_data.append(
              {
                  "Order ID": response["orderCreateTransaction"]["id"],
                  "Instrument": response["orderCreateTransaction"]["instrument"],
                  "Price": response["orderCreateTransaction"]["price"],
                  "Units": response["orderCreateTransaction"]["units"],
              }
          )
  
          df = pd.DataFrame.from_dict(order_data)
          print(df.to_string(index=False))
          print("")
  
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["errorMessage"], "\n")
      except Exception as e:
          print(e)
  
  
  def cancel_pending_order(accountID, other_args: List[str]):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="cancel",
          description="Cancel Pending Order ",
      )
      parser.add_argument(
          "-i",
          "--id",
          dest="orderID",
          action="store",
          type=str,
          help="The pending order ID to cancel ",
      )
      if other_args:
          if "-" not in other_args[0]:
              other_args.insert(0, "-i")
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
      try:
          request = orders.OrderCancel(accountID, ns_parser.orderID)
          response = client.request(request)
          order_id = response["orderCancelTransaction"]["orderID"]
          print(f"Order {order_id} canceled.")
          print("")
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["errorMessage"], "\n")
  
  
  def get_pending_orders(accountID, other_args):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="pending",
          description="Gets information about pending orders.",
      )
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
  
      try:
          request = orders.OrdersPending(accountID)
          response = client.request(request)
          pending_data = []
          for i in range(len(response["orders"])):
              pending_data.append(
                  {
                      "Order ID": response["orders"][i]["id"],
                      "Instrument": response["orders"][i]["instrument"],
                      "Price": response["orders"][i]["price"],
                      "Units": response["orders"][i]["units"],
                      "Time Created": response["orders"][i]["createTime"][:10]
                      + " "
                      + response["orders"][i]["createTime"][11:19],
                      "Time In Force": response["orders"][i]["timeInForce"],
                  }
              )
  
          df = pd.DataFrame.from_dict(pending_data)
          if not pending_data:
              print("No pending orders")
          else:
              print(df.to_string(index=False))
          print("")
  
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["errorMessage"], "\n")
  
  
  def get_open_positions(accountID, other_args):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="positions",
          description="Gets information about open positions.",
      )
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
      try:
          request = positions.OpenPositions(accountID)
          response = client.request(request)
          position_data = []
          for i in range(len(response["positions"])):
              position_data.append(
                  {
                      "Instrument": response["positions"][i]["instrument"],
                      "Long Units": response["positions"][i]["long"]["units"],
                      "Total Long P/L": response["positions"][i]["long"]["units"],
                      "Unrealized Long P/L": response["positions"][i]["long"][
                          "unrealizedPL"
                      ],
                      "Short Units": response["positions"][i]["short"]["units"],
                      "Total Short P/L": response["positions"][i]["short"]["pl"],
                      "Short Unrealized P/L": response["positions"][i]["short"][
                          "unrealizedPL"
                      ],
                  }
              )
  
          df = pd.DataFrame.from_dict(position_data)
          print(df.to_string(index=False))
          print("")
  
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["errorMessage"], "\n")
  
  
  def get_open_trades(accountID, other_args):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="trades",
          description="Gets information about open trades.",
      )
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
  
      try:
          request = trades.OpenTrades(accountID)
          response = client.request(request)
          try:
              df = pd.DataFrame.from_dict(response["trades"])
              df = df[
                  [
                      "id",
                      "instrument",
                      "initialUnits",
                      "currentUnits",
                      "price",
                      "unrealizedPL",
                  ]
              ]
              df = df.rename(
                  columns={
                      "id": "ID",
                      "instrument": "Instrument",
                      "initialUnits": "Initial Units",
                      "currentUnits": "Current Units",
                      "price": "Entry Price",
                      "unrealizedPL": "Unrealized P/L",
                  }
              )
  
              print(df.to_string(index=False))
              print("")
  
          except KeyError:
              print("No trades were found")
              print("")
      except V20Error as e:
          msg_length = len(e.msg)
          msg = e.msg[17 : msg_length - 2]
          print(msg)
          print("")
  
  
  def close_trade(accountID, other_args: List[str]):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="closetrade",
          description="Close a trade by id.",
      )
      parser.add_argument(
          "-i",
          "--id",
          dest="orderID",
          action="store",
          type=str,
          required=False,
          help="The Trade ID to close. ",
      )
      parser.add_argument(
          "-u",
          "--units",
          dest="units",
          action="store",
          required=False,
          help="The number of units on the trade to close. If not set it "
          + "defaults to all units. ",
      )
      if other_args:
          if "-i" not in other_args[0]:
              other_args.insert(0, "-i")
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
  
      data = {}
      if ns_parser.units is not None:
          data["units"] = ns_parser.units
      try:
          request = trades.TradeClose(accountID, ns_parser.orderID, data)
          response = client.request(request)
  
          close_data = []
          close_data.append(
              {
                  "OrderID": response["orderCreateTransaction"]["tradeClose"]["tradeID"],
                  "Instrument": response["orderFillTransaction"]["instrument"],
                  "Units": response["orderCreateTransaction"]["units"],
                  "Price": response["orderFillTransaction"]["price"],
                  "P/L": response["orderFillTransaction"]["pl"],
              }
          )
          df = pd.DataFrame.from_dict(close_data)
          print(df.to_string(index=False))
          print("")
  
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["errorMessage"], "\n")
      except Exception as e:
          print(e, "\n")
  
  
  def show_candles(accountID, instrument, other_args: List[str]):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="candles",
          description="Display Candle Data",
      )
      parser.add_argument(
          "-g",
          "--granularity",
          dest="granularity",
          action="store",
          type=str,
          default="D",
          required=False,
          help="The timeframe to get for the candle chart (Seconds: S5, S10, S15, S30 "
          + "Minutes: M1, M2, M4, M5, M10, M15, M30 Hours: H1, H2, H3, H4, H6, H8, H12 "
          + "Day (default): D, Week: W Month: M",
      )
      parser.add_argument(
          "-c",
          "--count",
          dest="candlecount",
          action="store",
          default=180,
          type=int,
          required=False,
          help="The number of candles to retrieve. Default:180 ",
      )
      parser.add_argument(
          "-a",
          "--ad",
          dest="ad",
          action="store_true",
          help="Adds ad (Accumulation/Distribution Indicator) to the chart",
      )
      parser.add_argument(
          "-b",
          "--bbands",
          dest="bbands",
          action="store_true",
          help="Adds Bollinger Bands to the chart",
      )
      parser.add_argument(
          "-C",
          "--cci",
          dest="cci",
          action="store_true",
          help="Adds cci (Commodity Channel Index) to the chart",
      )
      parser.add_argument(
          "-e",
          "--ema",
          dest="ema",
          action="store_true",
          help="Adds ema (Exponential Moving Average) to the chart",
      )
      parser.add_argument(
          "-o",
          "--obv",
          dest="obv",
          action="store_true",
          help="Adds obv (On Balance Volume) to the chart",
      )
      parser.add_argument(
          "-r",
          "--rsi",
          dest="rsi",
          action="store_true",
          help="Adds rsi (Relative Strength Index) to the chart",
      )
      parser.add_argument(
          "-s",
          "--sma",
          dest="sma",
          action="store_true",
          help="Adds sma (Simple Moving Average) to the chart",
      )
      parser.add_argument(
          "-v",
          "--vwap",
          dest="vwap",
          action="store_true",
          help="Adds vwap (Volume Weighted Average Price) to the chart",
      )
  
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
  
      parameters = {}
      parameters["granularity"] = ns_parser.granularity.upper()
      parameters["count"] = ns_parser.candlecount
      try:
          instrument = format_instrument(instrument, "_")
          df = get_candles_dataframe(accountID, instrument, parameters)
  
          plots_to_add, legends, subplot_legends = add_plots(df, ns_parser)
  
          if gtff.USE_ION:
              plt.ion()
  
          # pylint: disable=W0612
          fig, ax = mpf.plot(
              df,
              type="candle",
              style="charles",
              volume=True,
              title=f"{instrument} {ns_parser.granularity}",
              returnfig=True,
              addplot=plots_to_add,
          )
  
          ax[0].set_title(f"{instrument} {ns_parser.granularity}")
          ax[0].legend(legends)
          # pylint: disable=C0200
          for i in range(0, len(subplot_legends), 2):
              ax[subplot_legends[i]].legend(subplot_legends[i + 1])
  
          print("")
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["errorMessage"], "\n")
      except TypeError as e:
          print(e)
  
  
  def add_plots(df, ns_parser):
      panel_number = 2
      plots_to_add = []
      legends = []
      subplot_legends = []
  
      if ns_parser.ad:
          ad = ta.ad(df["High"], df["Low"], df["Close"], df["Volume"])
          ad_plot = mpf.make_addplot(ad, panel=panel_number)
          plots_to_add.append(ad_plot)
          subplot_legends.extend([panel_number * 2, ["AD"]])
          panel_number += 1
  
      if ns_parser.bbands:
          bbands = ta.bbands(df["Close"])
          bbands = bbands.drop("BBB_5_2.0", axis=1)
          bbands_plot = mpf.make_addplot(bbands, panel=0)
          plots_to_add.append(bbands_plot)
          legends.extend(["Lower BBand", "Middle BBand", "Upper BBand"])
  
      if ns_parser.cci:
          cci = ta.cci(df["High"], df["Low"], df["Close"])
          cci_plot = mpf.make_addplot(cci, panel=panel_number)
          plots_to_add.append(cci_plot)
          subplot_legends.extend([panel_number * 2, ["CCI"]])
          panel_number += 1
  
      if ns_parser.ema:
          ema = ta.ema(df["Close"])
          ema_plot = mpf.make_addplot(ema, panel=0)
          plots_to_add.append(ema_plot)
          legends.append("10 EMA")
  
      if ns_parser.rsi:
          rsi = ta.rsi(df["Close"])
          rsi_plot = mpf.make_addplot(rsi, panel=panel_number)
          plots_to_add.append(rsi_plot)
          subplot_legends.extend([panel_number * 2, ["RSI"]])
          panel_number += 1
  
      if ns_parser.obv:
          obv = ta.obv(df["Close"], df["Volume"])
          obv_plot = mpf.make_addplot(obv, panel=panel_number)
          plots_to_add.append(obv_plot)
          subplot_legends.extend([panel_number * 2, ["OBV"]])
          panel_number += 1
  
      if ns_parser.sma:
          sma_length = [20, 50]
          for length in sma_length:
              sma = ta.sma(df["Close"], length=length)
              sma_plot = mpf.make_addplot(sma, panel=0)
              plots_to_add.append(sma_plot)
              legends.append(f"{length} SMA")
  
      if ns_parser.vwap:
          vwap = ta.vwap(df["High"], df["Low"], df["Close"], df["Volume"])
          vwap_plot = mpf.make_addplot(vwap, panel=0)
          plots_to_add.append(vwap_plot)
          legends.append("vwap")
  
      return plots_to_add, legends, subplot_legends
  
  
  def calendar(instrument, other_args: List[str]):
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="calendar",
          description="Show Calendar Data",
      )
      parser.add_argument(
          "-d",
          "--days",
          dest="days",
          action="store",
          type=int,
          default=7,
          required=False,
          help="The number of days to search for, up to 30 forward or backward "
          + "use negative numbers to search back. ",
      )
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
  
      parameters = {"instrument": instrument, "period": str(ns_parser.days * 86400 * -1)}
      try:
          request = forexlabs.Calendar(params=parameters)
          response = client.request(request)
  
          l_data = []
          # pylint: disable=C0200
          for i in range(len(response)):
              if "forecast" in response[i]:
                  forecast = response[i]["forecast"]
                  if response[i]["unit"] != "Index":
                      forecast += response[i]["unit"]
              else:
                  forecast = ""
  
              if "market" in response[i]:
                  market = response[i]["market"]
                  if response[i]["unit"] != "Index":
                      market += response[i]["unit"]
              else:
                  market = ""
  
              if "actual" in response[i]:
                  actual = response[i]["actual"]
                  if response[i]["unit"] != "Index":
                      actual += response[i]["unit"]
              else:
                  actual = ""
  
              if "previous" in response[i]:
                  previous = response[i]["previous"]
                  if response[i]["unit"] != "Index":
                      previous += response[i]["unit"]
              else:
                  previous = ""
  
              if "impact" in response[i]:
                  impact = response[i]["impact"]
              else:
                  impact = ""
  
              l_data.append(
                  {
                      "Title": response[i]["title"],
                      "Time": datetime.fromtimestamp(response[i]["timestamp"]),
                      "Impact": impact,
                      "Forecast": forecast,
                      "Market Forecast": market,
                      "Currency": response[i]["currency"],
                      "Region": response[i]["region"],
                      "Actual": actual,
                      "Previous": previous,
                  }
              )
  
          print(pd.DataFrame(l_data).to_string(index=False))
          print("")
  
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["message"], "\n")
  
  
  # pylint: disable=W0613
  # pylint: disable=R1710
  def get_candles_dataframe(accountID, instrument, parameters):
      if not parameters:
          parameters = {
              "granularity": "D",
              "count": "1500",
          }
      try:
          request = instruments.InstrumentsCandles(instrument, params=parameters)
          response = client.request(request)
          candles_data = []
          for i in range(len(response["candles"])):
              candles_data.append(
                  {
                      "Date": response["candles"][i]["time"][:10]
                      + " "
                      + response["candles"][i]["time"][11:19],
                      "Open": float(response["candles"][i]["mid"]["o"]),
                      "High": float(response["candles"][i]["mid"]["h"]),
                      "Low": float(response["candles"][i]["mid"]["l"]),
                      "Close": float(response["candles"][i]["mid"]["c"]),
                      "Volume": response["candles"][i]["volume"],
                  }
              )
          df = pd.DataFrame(candles_data)
          df.set_index("Date", inplace=True)
          df.index = pd.to_datetime(df.index)
          return df
      except V20Error as e:
          # pylint: disable=W0123
          d_error = eval(e.msg)
          print(d_error["errorMessage"], "\n")
  
  
  # pylint: disable=R1710
  def load(other_args: List[str]):
      """Load a forex instrument to use"""
      parser = argparse.ArgumentParser(
          add_help=False,
          prog="load",
          description="Forex using oanda",
      )
  
      parser.add_argument(
          "-i",
          "--instrument",
          required=True,
          type=str,
          dest="instrument",
          help="Forex pair to use. ",
      )
      if other_args:
          if "-" not in other_args[0]:
              other_args.insert(0, "-i")
  
      ns_parser = parse_known_args_and_warn(parser, other_args)
      if not ns_parser:
          return
  
      print("")
      return ns_parser.instrument.upper()
  
  
  def book_plot(df, instrument, book_type):
      _, ax = plt.subplots(figsize=plot_autoscale(), dpi=cfgPlot.PLOT_DPI)
      df = df.apply(pd.to_numeric)
      df["shortCountPercent"] = df["shortCountPercent"] * -1
      axis_origin = max(
          abs(max(df["longCountPercent"])), abs(max(df["shortCountPercent"]))
      )
      ax.set_xlim(-axis_origin, +axis_origin)
  
      sns.set_style(style="darkgrid")
  
      sns.barplot(
          x="longCountPercent",
          y="price",
          data=df,
          label="Count Percent",
          color="green",
          orient="h",
      )
  
      sns.barplot(
          x="shortCountPercent",
          y="price",
          data=df,
          label="Prices",
          color="red",
          orient="h",
      )
  
      ax.invert_yaxis()
      plt.title(f"{instrument} {book_type}")
      plt.xlabel("Count Percent")
      plt.ylabel("Price")
      sns.despine(left=True, bottom=True)
      ax.yaxis.set_major_locator(mticker.MultipleLocator(5))
      if gtff.USE_ION:
          plt.ion()
      plt.show()
  
  
  # pylint: disable=R1710
  def format_instrument(instrument, char):
      try:
          if char not in instrument:
              instrument_list = list(instrument)
              instrument_list.pop(3)
              if char == " ":
                  instrument = "".join(map(str, instrument_list))
              else:
                  instrument_list.insert(3, char)
                  instrument = "".join(map(str, instrument_list))
          return instrument
      except TypeError:
          print("Please load an instrument")
          print("")
  