docs: def setup(self,
                data,
                view='hypergrid',
                schema=None,
                columns=None,
                rowpivots=None,
                columnpivots=None,
                aggregates=None,
                sort=None,
                index='',
                limit=-1,
                computedcolumns=None,
                settings=True,
                embed=False,
                dark=False,
                *args,
                **kwargs):
          '''Setup perspective base class
  
          Arguments:
              data : dataframe/list/dict
                  The static or live datasource
  
          Keyword Arguments:
              view : str or View
                  what view to use. available in the enum View (default: {'hypergrid'})
              columns : list of str
                  what columns to display
              rowpivots : list of str
                  what names to use as rowpivots
              columnpivots : list of str
                  what names to use as columnpivots
              aggregates:  dict(str: str or Aggregate)
                  dictionary of name to aggregate type (either string or enum Aggregate)
              index : str
                  columns to use as index
              limit : int
                  row limit
              computedcolumns : list of dict
                  computed columns to set on the perspective viewer
              settings : bool
                  display settings
              settings : bool
                  embedded mode
              dark : bool
                  use dark theme
  
          '''
          self.view = validate_view(view)
          self.schema = schema or {}
          self.sort = validate_sort(sort) or []
          self.index = index
          self.limit = limit
          self.settings = settings
          self.embed = embed
          self.dark = dark
  
          self.rowpivots = validate_rowpivots(rowpivots) or []
          self.columnpivots = validate_columnpivots(columnpivots) or []
          self.aggregates = validate_aggregates(aggregates) or {}
  
          self.columns = validate_columns(columns) or []
          self.computedcolumns = validate_computedcolumns(computedcolumns) or []
          self.load(data)