class_docstr: VisualChart Data Feed.
  
  Params:
  
    - ``qcheck`` (default: ``0.5``)
      Default timeout for waking up to let a resampler/replayer that the
      current bar can be check for due delivery
  
      The value is only used if a resampling/replaying filter has been
      inserted in the data
  
    - ``historical`` (default: ``False``)
      If no ``todate`` parameter is supplied (defined in the base class),
      this will force a historical only download if set to ``True``
  
      If ``todate`` is supplied the same effect is achieved
  
    - ``milliseconds`` (default: ``True``)
      The bars constructed by *Visual Chart* have this aspect:
      HH:MM:59.999000
  
      If this parameter is ``True`` a millisecond will be added to this time
      to make it look like: HH::MM + 1:00.000000
  
    - ``tradename`` (default: ``None``)
      Continous futures cannot be traded but are ideal for data tracking. If
      this parameter is supplied it will be the name of the current future
      which will be the trading asset. Example:
  
      - 001ES -> ES-Mini continuous supplied as ``dataname``
  
      - ESU16 -> ES-Mini 2016-09. If this is supplied in ``tradename`` it
        will be the trading asset.
  
    - ``usetimezones`` (default: ``True``)
      For most markets the time offset information provided by *Visual Chart*
      allows for datetime to be converted to market time (*backtrader* choice
      for representation)
  
      Some markets are special (``096``) and need special internal coverage
      and timezone support to display in the user expected market time.
  
      If this parameter is set to ``True`` importing ``pytz`` will be
      attempted to use timezones (default)
  
      Disabling it will remove timezone usage (may help if the load is
      excesive)
docstr: Starts the VC connecction and gets the real contract and
  contractdetails if it exists
docstr_tok: ["Starts","the","VC","connecction","and","gets","the","real","contract","and","contractdetails","if","it","exists"]
code: def start(self):
      """Starts the VC connecction and gets the real contract and
      contractdetails if it exists"""
      super(VCData, self).start()
  
      self._state = self._ST_START  # mini finite state machine
  
      self._newticks = True  # control processing of initial ticks
  
      self._pingtmout = self.PING_TIMEOUT  # Initial timeout for ping
  
      self.idx = 1  # counter for the dataserie (vb is based at 1)
      self.q = None  # where bars are received
  
      # market time offsets
      self._mktoffset = None
      self._mktoff1 = None
      self._mktoffdiff = None
  
      if not self.store.connected():
          # Not connected -> go away
          self.put_notification(self.DISCONNECTED)
          self._state = self._ST_NOTFOUND
          return
  
      self.put_notification(self.CONNECTED)
      # get real contract details with real conId (contractId)
      self.qrt = queue.Queue()  # to await a ping
      self.store._rtdata(self, self._dataname)
      symfound = self.qrt.get()
      if not symfound:
          # Kill any further action and signal it
          self.put_notification(self.NOTSUBSCRIBED)
          self.put_notification(self.DISCONNECTED)
          self._state = self._ST_NOTFOUND
          return
  
      if self.replaying:
          # In this case don't request the final
          # timeframe from vc, but the original that has to be replayed
          self._tf, self._comp = self.p.timeframe, self.p.compression
      else:
          # Else (even if resampling) pass the final timeframe which may
          # been modified by a resampling filter
          self._tf, self._comp = (
              self._timeframe,
              self._compression,
          )
  
      self._ticking = self.store._ticking(self._tf)
      self._syminfo = syminfo = self.store._symboldata(self._dataname)
  
      # For most markets:
      # mktoffset == mktoff1 and substracting this value from reported times
      # is enough to report the "market time". Visual Chart changes this from
      # a value X to 0 if the appropriate setting in the GUI is changed to
      # change display of time from local <-> market
      #
      # But some markets (at least 096XXX) that theoretically live in
      # Europe/London seem to be displaced 1 hour to the west and an extra
      # hour is needed.
      # These markets do also need "usetimezoned" True to actually display
      # the market time, because this is done internally using the
      # definitions in TZOUTS
  
      # Record and calculate market offsets
      self._mktoffset = timedelta(seconds=syminfo.TimeOffset)
      # Add millisecond to pusth HH:MM:59.999 -> 00.000 unless ticks
      if self.p.millisecond and not self._ticking:
          self._mktoffset -= self.MILLISECOND
  
      self._mktoff1 = self._mktoffset
      if self._mktcode in self._EXTRA_TIMEOFFSET:
          # These codes live theoretically in
          # (UTC+00:00) Dublin, Edinburgh, Lisbon, London which is
          # 'Europe/London'
          # But all experiments show the times to be displaced 1 hour to
          # the west and hence the extra 3600 seconds
          self._mktoffset -= timedelta(seconds=3600)
  
      self._mktoffdiff = self._mktoffset - self._mktoff1
  
      if self._state == self._ST_START:
          self.put_notification(self.DELAYED)
  
          # Now request the data and get a comms queue for it
          self.q = self.store._directdata(
              self,
              self._dataname,
              self._tf,
              self._comp,
              self.p.fromdate,
              self.p.todate,
              self.p.historical,
          )
  
          self._state = self._ST_FEEDING
  
imports: from __future__ import absolute_import, division, print_function, unicode_literals
  from datetime import datetime, timedelta, tzinfo
  import backtrader
  from backtrader import TimeFrame, date2num, num2date
  from backtrader.feed import DataBase
  from backtrader.metabase import MetaParams
  from backtrader.utils.py3 import integer_types, queue, string_types, with_metaclass
  from backtrader.stores import vcstore
label_desc: Use image node_id 7 for calling the VCData obj's underlying member method code with example usage: obj.start() without return types