castorini · lintool · Aug 6, 2020 · Jun 21, 2020 · Jul 25, 2020 · Jul 25, 2020
diff --git a/docs/usage-indexreader.md b/docs/usage-indexreader.md
@@ -72,6 +72,15 @@ print(doc_vector)
 ```
 
 The result is a dictionary where the keys are the analyzed terms and the values are the term frequencies.
+
+If you want to know the positions of each term in the document, you can use `get_term_positions`:
+```python
+term_positions, indexed_doc = index_reader.get_term_positions('FBIS4-67701')
+print(term_positions)
+print(indexed_doc)
+```
+The result is a tuple. The first member is a dictionary where the keys are the analyzed terms and the values are the positions each term occur in the document. The second member is a string containing the recovered document content using the position information.
+
 To compute the tf-idf representation of a document, do something like this:
 
 ```python

diff --git a/pyserini/index/_base.py b/pyserini/index/_base.py
@@ -260,6 +260,35 @@ def get_document_vector(self, docid: str) -> Optional[Dict[str, int]]:
             doc_vector_dict[term] = doc_vector_map.get(JString(term.encode('utf-8')))
         return doc_vector_dict
 
+    def get_term_positions(self, docid: str) -> Optional[Tuple[Dict[str, int], str]]:
+        """Return the term position mapping of the document with ``docid`` and the recovered document using the list. Note that
+        the term in the document is stemmed and stop words may be removed according to your index settings. Also,
+        requesting the document vector of a ``docid`` that does not exist in the index will return ``None`` (as opposed
+        to an empty dictionary); this forces the caller to handle ``None`` explicitly and guards against silent errors.
+
+        Parameters
+        ----------
+        docid : str
+            Collection ``docid``.
+
+        Returns
+        -------
+        Optional[Tuple[Dict[str, int], str]]
+            A tuple contains a dictionary with analyzed terms as keys and corresponding posting list as values, and a
+            string representing the recovered document
+        """
+        java_term_position_map = self.object.getTermPositions(self.reader, JString(docid))
+        if java_term_position_map is None:
+            return None
+        term_position_map = {}
+        term_pos = []
+        for term in java_term_position_map.keySet().toArray():
+            term_position_map[term] = java_term_position_map.get(JString(term.encode('utf-8'))).toArray()
+            for p in term_position_map[term]:
+                term_pos.append((term, p))
+        term_pos = sorted(term_pos, key=lambda x: x[1])
+        return term_position_map, ' '.join([t for t, p in term_pos])
+
     def doc(self, docid: str) -> Optional[Document]:
         """Return the :class:`Document` corresponding to ``docid``. Returns ``None`` if the ``docid`` does not exist
         in the index.