Add session reuse for pagination (#65)

Author: J535D165

pyalex/api.py

@@ -338,14 +338,12 @@ def __init__(
         self.value = value
         self.per_page = per_page
         self.n_max = n_max
-        # The current number of results retrieved.
         self.n = 0
 
         self._next_value = value
+        self._session = _get_requests_session()
 
     def __iter__(self):
-        self.n = 0
-
         return self
 
     def _is_max(self):
@@ -358,13 +356,22 @@ def __next__(self):
             raise StopIteration
 
         if self.method == "cursor":
-            pagination_params = {"cursor": self._next_value}
+            self.endpoint_class._add_params("cursor", self._next_value)
         elif self.method == "page":
-            pagination_params = {"page": self._next_value}
+            self.endpoint_class._add_params("page", self._next_value)
         else:
-            raise ValueError()
+            raise ValueError("Method should be 'cursor' or 'page'")
+
+        if self.per_page is not None and (
+            not isinstance(self.per_page, int)
+            or (self.per_page < 1 or self.per_page > 200)
+        ):
+            raise ValueError("per_page should be a integer between 1 and 200")
+
+        if self.per_page is not None:
+            self.endpoint_class._add_params("per-page", self.per_page)
 
-        r = self.endpoint_class.get(per_page=self.per_page, **pagination_params)
+        r = self.endpoint_class._get_from_url(self.endpoint_class.url, self._session)
 
         if self.method == "cursor":
             self._next_value = r.meta["next_cursor"]
@@ -501,8 +508,11 @@ def count(self):
         """
         return self.get(per_page=1).meta["count"]
 
-    def _get_from_url(self, url):
-        res = _get_requests_session().get(url, auth=OpenAlexAuth(config))
+    def _get_from_url(self, url, session=None):
+        if session is None:
+            session = _get_requests_session()
+
+        res = session.get(url, auth=OpenAlexAuth(config))
 
         if res.status_code == 403:
             if (
@@ -528,8 +538,10 @@ def _get_from_url(self, url):
             raise ValueError("Unknown response format")
 
     def get(self, return_meta=False, page=None, per_page=None, cursor=None):
-        if per_page is not None and (per_page < 1 or per_page > 200):
-            raise ValueError("per_page should be a number between 1 and 200.")
+        if per_page is not None and (
+            not isinstance(per_page, int) or (per_page < 1 or per_page > 200)
+        ):
+            raise ValueError("per_page should be an integer between 1 and 200")
 
         if not isinstance(self.params, (str, list)):
             self._add_params("per-page", per_page)
@@ -570,7 +582,7 @@ def paginate(self, method="cursor", page=1, per_page=None, cursor="*", n_max=100
             Paginator object.
         """
         if method == "cursor":
-            if self.params is not None and self.params.get("sample"):
+            if isinstance(self.params, dict) and self.params.get("sample"):
                 raise ValueError("method should be 'page' when using sample")
             value = cursor
         elif method == "page":

tests/test_paging.py

@@ -7,6 +7,10 @@
 pyalex.config.max_retries = 10
 
 
+def test_cursor_no_filter():
+    assert len(list(pyalex.Works().paginate(per_page=200, n_max=1000))) == 5
+
+
 def test_cursor():
     query = Authors().search_filter(display_name="einstein")
 
@@ -73,6 +77,28 @@ def test_paginate_counts():
     assert r.meta["count"] == n_p_page >= n_p_default == n_p_cursor
 
 
+def test_paginate_per_page():
+    assert all(len(page) <= 10 for page in Authors().paginate(per_page=10, n_max=50))
+
+
+def test_paginate_per_page_200():
+    assert all(len(page) == 200 for page in Authors().paginate(per_page=200, n_max=400))
+
+
+def test_paginate_per_page_none():
+    assert all(len(page) == 25 for page in Authors().paginate(n_max=500))
+
+
+def test_paginate_per_page_1000():
+    with pytest.raises(ValueError):
+        assert next(Authors().paginate(per_page=1000))
+
+
+def test_paginate_per_page_str():
+    with pytest.raises(ValueError):
+        assert next(Authors().paginate(per_page="100"))
+
+
 def test_paginate_instance():
     p_default = Authors().search_filter(display_name="einstein").paginate(per_page=200)
     assert isinstance(p_default, Paginator)

tests/test_pyalex.py

@@ -76,6 +76,20 @@ def test_per_page():
     assert len(Works().filter(publication_year=2020).get(per_page=200)) == 200
 
 
+def test_per_page_none():
+    assert len(Works().filter(publication_year=2020).get(per_page=None)) == 25
+
+
+def test_per_page_1000():
+    with pytest.raises(ValueError):
+        Works().filter(publication_year=2020).get(per_page=1000)
+
+
+def test_per_page_str():
+    with pytest.raises(ValueError):
+        Works().filter(publication_year=2020).get(per_page="100")
+
+
 def test_W4238809453_works():
     assert isinstance(Works()["W4238809453"], Work)
     assert Works()["W4238809453"]["doi"] == "https://doi.org/10.1001/jama.264.8.944b"