code: def compute_ranges(self, obj, key, ranges):
          
          all_table = all(isinstance(el, Table) for el in obj.traverse(lambda x: x, [Element]))
          if obj is None or not self.normalize or all_table:
              return OrderedDict()
          # Get inherited ranges
          ranges = self.ranges if ranges is None else dict(ranges)
  
          # Get element identifiers from current object and resolve
          # with selected normalization options
          norm_opts = self._get_norm_opts(obj)
  
          # Traverse displayed object if normalization applies
          # at this level, and ranges for the group have not
          # been supplied from a composite plot
          return_fn = lambda x: x if isinstance(x, Element) else None
          for group, (axiswise, framewise) in norm_opts.items():
              elements = []
              # Skip if ranges are cached or already computed by a
              # higher-level container object.
              framewise = framewise or self.dynamic or len(elements) == 1
              if group in ranges and (not framewise or ranges is not self.ranges):
                  continue
              elif not framewise: # Traverse to get all elements
                  elements = obj.traverse(return_fn, [group])
              elif key is not None: # Traverse to get elements for each frame
                  frame = self._get_frame(key)
                  elements = [] if frame is None else frame.traverse(return_fn, [group])
              # Only compute ranges if not axiswise on a composite plot
              # or not framewise on a Overlay or ElementPlot
              if (not (axiswise and not isinstance(obj, HoloMap)) or
                  (not framewise and isinstance(obj, HoloMap))):
                  self._compute_group_range(group, elements, ranges)
          self.ranges.update(ranges)
          return ranges
docs: Given an object, a specific key, and the normalization options,
          this method will find the specified normalization options on
          the appropriate OptionTree, group the elements according to
          the selected normalization option (i.e. either per frame or
          over the whole animation) and finally compute the dimension
          ranges in each group. The new set of ranges is returned.