docs: def sendSync(self, query, *parameters, **options):
          '''Performs a synchronous query against a q service and returns parsed 
          data.
          
          In typical use case, `query` is the name of the function to call and 
          `parameters` are its parameters. When `parameters` list is empty, the 
          query can be an arbitrary q expression (e.g. ``0 +/ til 100``).
          
          Executes a q expression:
          
              >>> print(q.sendSync('til 10'))
              [0 1 2 3 4 5 6 7 8 9]
          
          Executes an anonymous q function with a single parameter:
          
              >>> print(q.sendSync('{til x}', 10))
              [0 1 2 3 4 5 6 7 8 9]
              
          Executes an anonymous q function with two parameters:
          
              >>> print(q.sendSync('{y + til x}', 10, 1))
              [ 1  2  3  4  5  6  7  8  9 10]
              
              >>> print(q.sendSync('{y + til x}', *[10, 1]))
              [ 1  2  3  4  5  6  7  8  9 10]
          
          The :func:`.sendSync` is called from the overloaded :func:`.__call__` 
          function. This allows :class:`.QConnection` instance to be called as 
          a function:
          
              >>> print(q('{y + til x}', 10, 1))
              [ 1  2  3  4  5  6  7  8  9 10]
          
          
          :Parameters:
           - `query` (`string`) - query to be executed
           - `parameters` (`list` or `None`) - parameters for the query
          :Options: 
           - `raw` (`boolean`) - if ``True`` returns raw data chunk instead of 
             parsed data, **Default**: ``False``
           - `numpy_temporals` (`boolean`) - if ``False`` temporal vectors are
             backed by raw q representation (:class:`.QTemporalList`, 
             :class:`.QTemporal`) instances, otherwise are represented as 
             `numpy datetime64`/`timedelta64` arrays and atoms,
             **Default**: ``False``
           - `single_char_strings` (`boolean`) - if ``True`` single char Python 
             strings are encoded as q strings instead of chars, 
             **Default**: ``False``
  
          :returns: query result parsed to Python data structures
          
          :raises: :class:`.QConnectionException`, :class:`.QWriterException`, 
                   :class:`.QReaderException`
          '''
          self.query(MessageType.SYNC, query, *parameters, **options)
          response = self.receive(data_only = False, **options)
  
          if response.type == MessageType.RESPONSE:
              return response.data
          else:
              self._writer.write(QException('nyi: qPython expected response message'), MessageType.ASYNC if response.type == MessageType.ASYNC else MessageType.RESPONSE)
              raise QReaderException('Received message of type: %s where response was expected')