class_docstr: Line graph class
class_docstr_tok: ["Line","graph","class"]
docstr: Draw the line serie
docstr_tok: ["Draw","the","line","serie"]
code: def line(self, serie, rescale=False):
      """Draw the line serie"""
      serie_node = self.svg.serie(serie)
      if rescale and self.secondary_series:
          points = self._rescale(serie.points)
      else:
          points = serie.points
      view_values = list(map(self.view, points))
      if serie.show_dots:
          for i, (x, y) in enumerate(view_values):
              if None in (x, y):
                  continue
              if self.logarithmic:
                  if points[i][1] is None or points[i][1] <= 0:
                      continue
              if (
                  serie.show_only_major_dots
                  and self.x_labels
                  and i < len(self.x_labels)
                  and self.x_labels[i] not in self._x_labels_major
              ):
                  continue
  
              metadata = serie.metadata.get(i)
              classes = []
              if x > self.view.width / 2:
                  classes.append("left")
              if y > self.view.height / 2:
                  classes.append("top")
              classes = " ".join(classes)
  
              self._confidence_interval(
                  serie_node["overlay"], x, y, serie.values[i], metadata
              )
  
              dots = decorate(
                  self.svg,
                  self.svg.node(serie_node["overlay"], class_="dots"),
                  metadata,
              )
  
              val = self._format(serie, i)
              alter(
                  self.svg.transposable_node(
                      dots,
                      "circle",
                      cx=x,
                      cy=y,
                      r=serie.dots_size,
                      class_="dot reactive tooltip-trigger",
                  ),
                  metadata,
              )
              self._tooltip_data(
                  dots, val, x, y, xlabel=self._get_x_label(i)
              )
              self._static_value(
                  serie_node,
                  val,
                  x + self.style.value_font_size,
                  y + self.style.value_font_size,
                  metadata,
              )
  
      if serie.stroke:
          if self.interpolate:
              points = serie.interpolated
              if rescale and self.secondary_series:
                  points = self._rescale(points)
              view_values = list(map(self.view, points))
          if serie.fill:
              view_values = self._fill(view_values)
  
          if serie.allow_interruptions:
              # view_values are in form [(x1, y1), (x2, y2)]. We
              # need to split that into multiple sequences if a
              # None is present here
  
              sequences = []
              cur_sequence = []
              for x, y in view_values:
                  if y is None and len(cur_sequence) > 0:
                      # emit current subsequence
                      sequences.append(cur_sequence)
                      cur_sequence = []
                  elif y is None:  # just discard
                      continue
                  else:
                      cur_sequence.append((x, y))  # append the element
  
              if len(cur_sequence) > 0:  # emit last possible sequence
                  sequences.append(cur_sequence)
          else:
              # plain vanilla rendering
              sequences = [view_values]
          if self.logarithmic:
              for seq in sequences:
                  for ele in seq[::-1]:
                      y = points[seq.index(ele)][1]
                      if y is None or y <= 0:
                          del seq[seq.index(ele)]
          for seq in sequences:
              self.svg.line(
                  serie_node["plot"],
                  seq,
                  close=self._self_close,
                  class_="line reactive"
                  + (" nofill" if not serie.fill else ""),
              )
  
file_path: pygal/pygal/graph/line.py
imports: from pygal.graph.graph import Graph
  from pygal.util import alter, cached_property, decorate
label_desc: Use image node_id 5 for calling the Line obj's underlying member method code with example usage: obj.line(serie, rescale) without return types