docs: def inputPoint(self):
          """
          Returns a scene space point that the connection \
          will draw to as its input target.  If the connection \
          has a node defined, then it will calculate the input \
          point based on the position of the node, factoring in \
          preference for input location and fixed information. \
          If there is no node connected, then the point defined \
          using the setInputPoint method will be used.
          
          :return     <QPointF>
          """
          node = self.inputNode()
  
          # return the set point
          if not node:
              return self._inputPoint
  
          # test for the hotspot
          hotspot = self.inputHotspot()
  
          # otherwise, calculate the point based on location and fixed info
          ilocation = self.inputLocation()
          ifixedx = self.inputFixedX()
          ifixedy = self.inputFixedY()
  
          loc_left = XNodeConnection.Location.Left
          loc_right = XNodeConnection.Location.Right
          loc_top = XNodeConnection.Location.Top
          loc_bot = XNodeConnection.Location.Bottom
  
          irect = self.inputRect()
          orect = self.outputRect()
  
          # return the left location
          if ilocation & loc_left and orect.right() < irect.left():
              if hotspot:
                  return node.mapToScene(QPointF(hotspot.rect().left(),
                                                 hotspot.rect().center().y()))
              else:
                  return node.positionAt(loc_left, ifixedx, ifixedy)
  
          # return the right location
          elif ilocation & loc_right and irect.left() < orect.right():
              if hotspot:
                  return node.mapToScene(QPointF(hotspot.rect().right(),
                                                 hotspot.rect().center().y()))
              else:
                  return node.positionAt(loc_right, ifixedx, ifixedy)
  
          # return the top location
          elif ilocation & loc_top and orect.bottom() < irect.top():
              if hotspot:
                  return node.mapToScene(QPointF(hotspot.rect().center().x(),
                                                 hotspot.rect().top()))
              else:
                  return node.positionAt(loc_top, ifixedx, ifixedy)
  
          # return the bottom location
          elif ilocation & loc_bot and irect.bottom() < orect.top():
              if hotspot:
                  return node.mapToScene(QPointF(hotspot.rect().center().x(),
                                                 hotspot.rect().bottom()))
              else:
                  return node.positionAt(loc_bot, ifixedx, ifixedy)
  
          # return the center location
          else:
              if hotspot:
                  return node.mapToScene(hotspot.rect().center())
              else:
                  return node.positionAt(ilocation, ifixedx, ifixedy)