arkindex-client 1.1.4__tar.gz → 1.2.0__tar.gz

{arkindex-client-1.1.4/arkindex_client.egg-info → arkindex_client-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: arkindex-client
-Version: 1.1.4
+Version: 1.2.0
 Summary: API client for the Arkindex project
 Home-page: https://gitlab.teklia.com/arkindex/api-client
 Author: Teklia <contact@teklia.com>
@@ -20,5 +20,18 @@ Classifier: Topic :: Text Processing :: Indexing
 Classifier: Topic :: Text Processing :: Linguistic
 Requires-Python: >=3.8
 License-File: LICENSE
+Requires-Dist: requests>=2.30
+Requires-Dist: tenacity>=9.1.0
+Requires-Dist: typesystem==0.4.1
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 Documentation is available at https://api.arkindex.org

arkindex_client-1.2.0/VERSION

@@ -0,0 +1 @@
+1.2.0

{arkindex-client-1.1.4 → arkindex_client-1.2.0}/arkindex/mock.py

@@ -2,6 +2,7 @@
 import collections
 import logging
 
+from arkindex import ArkindexClient
 from arkindex.exceptions import ErrorResponse
 
 logger = logging.getLogger(__name__)
@@ -9,10 +10,12 @@ logger = logging.getLogger(__name__)
 MockRequest = collections.namedtuple("MockRequest", "operation, body, args, kwargs")
 
 
-class MockApiClient(object):
+class MockApiClient(ArkindexClient):
     """A mockup of the Arkindex API Client to build unit tests"""
 
     def __init__(self):
+        super().__init__()
+
         self.history = []
         self.responses = []
 

{arkindex-client-1.1.4 → arkindex_client-1.2.0/arkindex_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: arkindex-client
-Version: 1.1.4
+Version: 1.2.0
 Summary: API client for the Arkindex project
 Home-page: https://gitlab.teklia.com/arkindex/api-client
 Author: Teklia <contact@teklia.com>
@@ -20,5 +20,18 @@ Classifier: Topic :: Text Processing :: Indexing
 Classifier: Topic :: Text Processing :: Linguistic
 Requires-Python: >=3.8
 License-File: LICENSE
+Requires-Dist: requests>=2.30
+Requires-Dist: tenacity>=9.1.0
+Requires-Dist: typesystem==0.4.1
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 Documentation is available at https://api.arkindex.org

{arkindex-client-1.1.4 → arkindex_client-1.2.0}/arkindex_client.egg-info/SOURCES.txt

@@ -2,12 +2,9 @@ LICENSE
 MANIFEST.in
 README.md
 VERSION
-requirements-docs.txt
 requirements.txt
 setup.cfg
 setup.py
-apistar/__init__.py
-apistar/exceptions.py
 arkindex/__init__.py
 arkindex/auth.py
 arkindex/compat.py
@@ -25,4 +22,10 @@ arkindex_client.egg-info/PKG-INFO
 arkindex_client.egg-info/SOURCES.txt
 arkindex_client.egg-info/dependency_links.txt
 arkindex_client.egg-info/requires.txt
-arkindex_client.egg-info/top_level.txt
+arkindex_client.egg-info/top_level.txt
+tests/test_auth.py
+tests/test_env.py
+tests/test_init.py
+tests/test_mock.py
+tests/test_pagination.py
+tests/test_request.py

{arkindex-client-1.1.4 → arkindex_client-1.2.0}/arkindex_client.egg-info/requires.txt

@@ -1,3 +1,3 @@
 requests>=2.30
-tenacity==8.2.3
+tenacity>=9.1.0
 typesystem==0.4.1

{arkindex-client-1.1.4 → arkindex_client-1.2.0}/arkindex_client.egg-info/top_level.txt

@@ -1,2 +1 @@
-apistar
 arkindex

{arkindex-client-1.1.4 → arkindex_client-1.2.0}/requirements.txt

@@ -1,3 +1,3 @@
 requests>=2.30
-tenacity==8.2.3
+tenacity>=9.1.0
 typesystem==0.4.1

arkindex_client-1.2.0/tests/test_auth.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+from responses import matchers
+
+
+def test_login(responses, dummy_client):
+    responses.add(
+        responses.POST,
+        "https://dummy.test/api/v1/user/login/",
+        json={"auth_token": "tolkien"},
+    )
+
+    assert dummy_client.session.auth.token is None
+    dummy_client.session.auth.scheme = "Beer"
+
+    assert dummy_client.login("user@user.user", "Pa$$w0rd") == {"auth_token": "tolkien"}
+
+    assert dummy_client.session.auth.token == "tolkien"
+    assert dummy_client.session.auth.scheme == "Token"
+
+
+def test_default_auth_scheme(responses, dummy_client):
+    responses.add(
+        responses.GET,
+        "https://dummy.test/api/v1/elements/",
+        match=[matchers.header_matcher({"Authorization": "Token ofgratitude"})],
+        json={"count": 0, "previous": None, "next": None, "results": []},
+    )
+
+    dummy_client.configure(token="ofgratitude")
+
+    assert dummy_client.request("ListElements") == {
+        "count": 0,
+        "previous": None,
+        "next": None,
+        "results": [],
+    }
+
+
+def test_custom_auth_scheme(responses, dummy_client):
+    responses.add(
+        responses.GET,
+        "https://dummy.test/api/v1/elements/",
+        match=[matchers.header_matcher({"Authorization": "Digest Food"})],
+        json={"count": 0, "previous": None, "next": None, "results": []},
+    )
+
+    dummy_client.configure(token="Food", auth_scheme="Digest")
+
+    assert dummy_client.request("ListElements") == {
+        "count": 0,
+        "previous": None,
+        "next": None,
+        "results": [],
+    }

arkindex_client-1.2.0/tests/test_env.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+import os
+
+import pytest
+
+from arkindex import options_from_env
+
+
+@pytest.mark.parametrize(
+    "env,expected",
+    [
+        ({}, {}),
+        ({"ARKINDEX_API_URL": "http://lol"}, {"base_url": "http://lol"}),
+        ({"ARKINDEX_API_SCHEMA_URL": "http://lol"}, {"schema_url": "http://lol"}),
+        ({"ARKINDEX_API_AUTH_SCHEME": "Bribe"}, {"auth_scheme": "Bribe"}),
+        (
+            {"ARKINDEX_API_CSRF_COOKIE": "raisin-oatmeal"},
+            {"csrf_cookie": "raisin-oatmeal"},
+        ),
+        (
+            {"ARKINDEX_API_TOKEN": "ofGoodWill"},
+            {"auth_scheme": "Token", "token": "ofGoodWill"},
+        ),
+        (
+            {"ARKINDEX_TASK_TOKEN": "Kimonos"},
+            {"auth_scheme": "Ponos", "token": "Kimonos"},
+        ),
+        # The task token should override the API token
+        (
+            {"ARKINDEX_API_TOKEN": "ofGoodWill", "ARKINDEX_TASK_TOKEN": "Kimonos"},
+            {"auth_scheme": "Ponos", "token": "Kimonos"},
+        ),
+        # The auth scheme can override the scheme set by the API token
+        (
+            {"ARKINDEX_API_TOKEN": "Bad", "ARKINDEX_API_AUTH_SCHEME": "Breaking"},
+            {"auth_scheme": "Breaking", "token": "Bad"},
+        ),
+        # The auth scheme can override the scheme set by the task token
+        (
+            {"ARKINDEX_TASK_TOKEN": "Bad", "ARKINDEX_API_AUTH_SCHEME": "Breaking"},
+            {"auth_scheme": "Breaking", "token": "Bad"},
+        ),
+        # Also try with both tokens set
+        (
+            {
+                "ARKINDEX_API_AUTH_SCHEME": "It",
+                "ARKINDEX_API_TOKEN": "Fails",
+                "ARKINDEX_TASK_TOKEN": "Works",
+            },
+            {"auth_scheme": "It", "token": "Works"},
+        ),
+        # Set everything at once
+        (
+            {
+                "ARKINDEX_API_URL": "http://lol",
+                "ARKINDEX_API_SCHEMA_URL": "http://lul",
+                "ARKINDEX_API_AUTH_SCHEME": "Roll",
+                "ARKINDEX_API_TOKEN": "d6",
+                "ARKINDEX_TASK_TOKEN": "d20",
+                "ARKINDEX_API_CSRF_COOKIE": "thin-mint",
+            },
+            {
+                "base_url": "http://lol",
+                "schema_url": "http://lul",
+                "auth_scheme": "Roll",
+                "token": "d20",
+                "csrf_cookie": "thin-mint",
+            },
+        ),
+    ],
+)
+def test_options_from_env(mocker, env, expected):
+    mocker.patch.dict(os.environ, env, clear=True)
+    assert options_from_env() == expected

arkindex_client-1.2.0/tests/test_init.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+from pathlib import Path
+
+import pytest
+import responses
+
+from arkindex import ArkindexClient
+from arkindex.exceptions import SchemaError
+
+DUMMY_SCHEMA = Path(__file__).absolute().parent / "schema.json"
+
+
+def test_invalid_url():
+    with pytest.raises(
+        SchemaError,
+        match=r"Could not retrieve a proper OpenAPI schema from http://aaa/api/v1/openapi/\?format=json",
+    ):
+        ArkindexClient(base_url="http://aaa")
+
+
+def test_http_error():
+    responses.add(
+        responses.GET,
+        "https://dummy.test/api/v1/openapi/?format=json",
+        status=418,
+    )
+    with pytest.raises(SchemaError):
+        ArkindexClient(base_url="https://dummy.test/")
+
+
+def test_invalid_json():
+    responses.add(
+        responses.GET,
+        "https://dummy.test/api/v1/openapi/?format=json",
+        body="{",
+    )
+    with pytest.raises(SchemaError):
+        ArkindexClient(base_url="https://dummy.test/")
+
+
+def test_no_endpoints():
+    responses.add(
+        responses.GET,
+        "https://dummy.test/api/v1/openapi/?format=json",
+        json={
+            "openapi": "3.0.2",
+            "info": {"title": "/dev/null", "version": "0"},
+            "paths": {},
+        },
+    )
+    with pytest.raises(
+        SchemaError,
+        match="An OpenAPI document must contain at least one valid operation.",
+    ):
+        ArkindexClient(base_url="https://dummy.test/")
+
+
+def test_schema_url():
+    with DUMMY_SCHEMA.open() as f:
+        responses.add(
+            responses.GET,
+            "http://dev/null",
+            body=f.read(),
+        )
+    cli = ArkindexClient(base_url="https://dummy.test/", schema_url="http://dev/null")
+    assert cli.document.url == "https://dummy.test/"
+    assert list(cli.document.links.keys()) == [
+        "ListElements",
+        "ListProcessElements",
+        "UploadDataFile",
+        "ListElementMetaData",
+        "Login",
+    ]
+
+
+def test_local_path():
+    cli = ArkindexClient(base_url="https://dummy.test/", schema_url=str(DUMMY_SCHEMA))
+    assert cli.document.url == "https://dummy.test/"
+    assert list(cli.document.links.keys()) == [
+        "ListElements",
+        "ListProcessElements",
+        "UploadDataFile",
+        "ListElementMetaData",
+        "Login",
+    ]

arkindex_client-1.2.0/tests/test_mock.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import pytest
+
+from arkindex.exceptions import ErrorResponse
+from arkindex.mock import MockApiClient
+
+
+def test_mock_client(responses):
+    # Allow accessing remote API schemas, defaulting to the prod environment
+    schema_url = os.environ.get(
+        "ARKINDEX_API_SCHEMA_URL",
+        "https://arkindex.teklia.com/api/v1/openapi/?format=json",
+    )
+    responses.add_passthru(schema_url)
+
+    # Configure mock for dummy endpoints
+    mock = MockApiClient()
+    mock.add_response(
+        "ListAnimals",
+        [
+            {
+                "type": "cat",
+                "name": "Henri",
+            },
+            {
+                "type": "dog",
+                "name": "Rick",
+            },
+        ],
+    )
+    invalid_body = mock.add_response(
+        "CreateTag",
+        name="Henri",
+        body={"tag": "This is not the right payload"},
+        response={
+            "id": "1234-cat",
+        },
+    )
+    mock.add_response(
+        "CreateTag",
+        name="Henri",
+        body={"tag": "yyy"},
+        response={
+            "id": "1234-cat",
+        },
+    )
+    extra_response = mock.add_response(
+        "CreateTag",
+        name="Nope",
+        response={
+            "id": "shouldNotAppear",
+        },
+    )
+    mock.add_response(
+        "CreateTag",
+        name="Rick",
+        body={"tag": "xxx"},
+        response={
+            "id": "5678-dog",
+        },
+    )
+    mock.add_error_response(
+        "DeleteTag",
+        name="Henri",
+        body={"tag": "yyy"},
+        status_code=403,
+        title="Forbidden",
+        content="You cannot perform this action",
+    )
+
+    # Call the endpoints - this simulates business code
+    animals = mock.paginate("ListAnimals")
+    assert len(animals) == 2
+    assert animals == [
+        {
+            "type": "cat",
+            "name": "Henri",
+        },
+        {
+            "type": "dog",
+            "name": "Rick",
+        },
+    ]
+
+    assert mock.request("CreateTag", name="Rick", body={"tag": "xxx"}) == {
+        "id": "5678-dog",
+    }
+    assert mock.request("CreateTag", name="Henri", body={"tag": "yyy"}) == {
+        "id": "1234-cat",
+    }
+
+    with pytest.raises(ErrorResponse) as e_info:
+        mock.request("DeleteTag", name="Henri", body={"tag": "yyy"})
+    error_response = e_info.value
+    assert error_response.status_code == 403
+    assert error_response.title == "Forbidden"
+    assert error_response.content == "You cannot perform this action"
+
+    # A request not mocked should raise an exception
+    with pytest.raises(ErrorResponse):
+        mock.request("DoSomething", parameter="value")
+
+    # Check the mockup history
+    assert len(mock.history) == 5
+    assert [req.operation for req in mock.history] == [
+        "ListAnimals",
+        "CreateTag",
+        "CreateTag",
+        "DeleteTag",
+        "DoSomething",
+    ]
+
+    # Almost all responses have been consumed
+    assert len(mock.responses) == 2
+    assert mock.responses == [invalid_body, extra_response]

arkindex_client-1.2.0/tests/test_pagination.py

@@ -0,0 +1,336 @@
+# -*G- coding: utf-8 -*-
+import logging
+import time
+
+import pytest
+import responses
+from responses import matchers
+
+from arkindex import ArkindexClient
+from arkindex.pagination import PaginationMode
+
+
+def test_pagination_empty(mock_schema):
+    responses.add(
+        responses.GET,
+        "https://dummy.test/api/v1/elements/",
+        json={"count": 0, "previous": None, "next": None, "results": []},
+    )
+
+    cli = ArkindexClient("t0k3n", base_url="https://dummy.test")
+    with pytest.raises(StopIteration):
+        next(cli.paginate("ListElements"))
+
+
+def test_page_mode_detection(mock_schema):
+    cli = ArkindexClient("t0k3n", base_url="https://dummy.test")
+    pagination = cli.paginate("ListElements")
+    responses.assert_call_count(
+        count=1, url="https://dummy.test/api/v1/openapi/?format=json"
+    )
+    assert pagination.mode is PaginationMode.PageNumber
+
+
+def test_cursor_mode_detection(mock_schema):
+    cli = ArkindexClient("t0k3n", base_url="https://dummy.test")
+    pagination = cli.paginate("ListProcessElements", id="process_id")
+    responses.assert_call_count(
+        count=1, url="https://dummy.test/api/v1/openapi/?format=json"
+    )
+    assert pagination.mode is PaginationMode.Cursor
+
+
+def test_page_pagination_with_missing_data(mock_schema, monkeypatch):
+    """
+    Page number pagination skips erroneous pages when allow_missing_data parameter is set
+    """
+    base_url = "https://dummy.test/api/v1/elements/"
+
+    # Disable sleeps
+    monkeypatch.setattr(time, "sleep", lambda x: None)
+
+    # Page 1
+    responses.add(
+        responses.GET,
+        base_url,
+        match=[matchers.query_param_matcher({})],
+        json={
+            "count": 9,
+            "number": 1,
+            "previous": None,
+            "next": f"{base_url}?page=2",
+            "results": [1, 2, 3],
+        },
+    )
+
+    # Page 2 is erroneous
+    # We need 3 responses, one for each retries
+    for i in range(3):
+        responses.add(
+            responses.GET,
+            base_url,
+            match=[matchers.query_param_matcher({"page": 2})],
+            status=400,
+            json={"error": "some error happened"},
+        )
+
+    # Page 3
+    responses.add(
+        responses.GET,
+        base_url,
+        match=[matchers.query_param_matcher({"page": 3})],
+        json={
+            "count": 9,
+            "number": 3,
+            "previous": f"{base_url}?page=3",
+            "next": None,
+            "results": [7, 8, 9],
+        },
+    )
+
+    cli = ArkindexClient("t0k3n", base_url="https://dummy.test")
+    paginator = cli.paginate("ListElements", allow_missing_data=True, retries=3)
+    assert paginator.allow_missing_data is True
+
+    # First page is retrieved
+    assert len(paginator) == 9
+    assert len(responses.calls) == 2
+    responses.assert_call_count(count=1, url=base_url)
+    # Remaining pages are retrieved with retries
+    assert list(paginator) == [1, 2, 3, 7, 8, 9]
+    assert len(responses.calls) == 6
+    responses.assert_call_count(count=3, url=f"{base_url}?page=2")
+    # Page 2 has failed
+    assert paginator.missing == {2}
+
+
+def test_page_pagination_incomplete(mock_schema, monkeypatch):
+    """
+    Pagination raises an exception on repeated errors by default
+    """
+    base_url = "https://dummy.test/api/v1/elements/"
+
+    # Disable sleeps
+    monkeypatch.setattr(time, "sleep", lambda x: None)
+
+    # Page 1
+    responses.add(
+        responses.GET,
+        base_url,
+        match=[matchers.query_param_matcher({})],
+        json={
+            "count": 9,
+            "number": 1,
+            "previous": None,
+            "next": f"{base_url}?page=2",
+            "results": ["A", "B"],
+        },
+    )
+
+    # Page 2 is erroneous
+    # Page 3 is not needed as it won't try to load it
+    responses.add(
+        responses.GET,
+        base_url,
+        match=[matchers.query_param_matcher({"page": 2})],
+        status=500,
+    )
+
+    cli = ArkindexClient("t0k3n", base_url="https://dummy.test")
+    paginator = cli.paginate("ListElements", retries=1)
+    assert paginator.allow_missing_data is False
+
+    with pytest.raises(
+        Exception, match="Stopping pagination as data will be incomplete"
+    ):
+        list(paginator)
+
+
+def test_cursor_pagination_length(mock_schema):
+    """
+    The first page should be retrieved with the `with_count` parameter in case of a cursor pagination
+    Allows the client to know the total number of results
+    """
+    base_url = "https://dummy.test/api/v1/process/process_id/elements/"
+
+    responses.add(
+        responses.GET,
+        base_url,
+        match=[matchers.query_param_matcher({"with_count": "true"})],
+        json={
+            "count": 6,
+            "previous": None,
+            "next": f"{base_url}?cursor=DEF",
+            "results": [1, 2, 3],
+        },
+    )
+    responses.add(
+        responses.GET,
+        base_url,
+        match=[matchers.query_param_matcher({"cursor": "DEF"})],
+        json={
+            "count": None,
+            "previous": f"{base_url}?cursor=ABC",
+            "next": None,
+            "results": [4, 5, 6],
+        },
+    )
+
+    cli = ArkindexClient("t0k3n", base_url="https://dummy.test")
+    paginator = cli.paginate("ListProcessElements", id="process_id")
+
+    assert len(paginator) == 6
+    assert len(responses.calls) == 2
+    # Schema is used to detect the pagination mode
+    responses.assert_call_count(
+        count=1, url="https://dummy.test/api/v1/openapi/?format=json"
+    )
+    responses.assert_call_count(count=1, url=f"{base_url}?with_count=true")
+    assert list(paginator) == list(range(1, 7))
+    assert len(responses.calls) == 3
+
+
+def test_cursor_pagination_zero_results(mock_schema):
+    """
+    Pagination should handle queries returning zero results
+    """
+    base_url = "https://dummy.test/api/v1/process/process_id/elements/"
+    responses.add(
+        responses.GET,
+        base_url,
+        match=[matchers.query_param_matcher({"with_count": "true"})],
+        json={
+            "count": 0,
+            "previous": None,
+            "next": None,
+            "results": [],
+        },
+    )
+
+    cli = ArkindexClient("t0k3n", base_url="https://dummy.test")
+    paginator = cli.paginate("ListProcessElements", id="process_id")
+
+    assert len(paginator) == 0
+    assert list(paginator) == []
+    assert len(responses.calls) == 2
+
+
+def test_cursor_pagination_len_errors(mock_schema, mocker):
+    """
+    Errors must be raised when calling the __len__ method of an iterator
+    """
+    base_url = "https://dummy.test/api/v1/process/process_id/elements/"
+    responses.add(
+        responses.GET,
+        base_url,
+        match=[matchers.query_param_matcher({"with_count": "true"})],
+        status=500,
+    )
+
+    # Prevent waiting for a random amount of time between retries
+    mocker.patch("arkindex.pagination.random.random", return_value=0.0001)
+
+    cli = ArkindexClient("t0k3n", base_url="https://dummy.test")
+    paginator = cli.paginate("ListProcessElements", id="process_id", retries=5)
+
+    with pytest.raises(
+        Exception, match="Stopping pagination as data will be incomplete"
+    ):
+        len(paginator)
+    assert len(responses.calls) == 6
+
+
+def test_paginate_x_paginated(mock_schema):
+    responses.add(
+        responses.GET,
+        "https://dummy.test/api/v1/element/element_id/metadata/",
+        match=[matchers.query_param_matcher({})],
+        json=["a", "b"],
+    )
+
+    cli = ArkindexClient("t0k3n", base_url="https://dummy.test")
+    assert cli.paginate("ListElementMetaData", id="element_id") == ["a", "b"]
+    assert len(responses.calls) == 2
+
+
+def test_paginate_from_initial_page(mock_schema, caplog):
+    caplog.set_level(logging.INFO)
+    base_url = "https://dummy.test/api/v1/elements/"
+
+    responses.add(
+        responses.GET,
+        base_url,
+        match=[matchers.query_param_matcher({"page": "2"})],
+        json={
+            "count": 9,
+            "number": 1,
+            "previous": f"{base_url}?page=1",
+            "next": f"{base_url}?page=3",
+            "results": [4, 5, 6],
+        },
+    )
+    responses.add(
+        responses.GET,
+        base_url,
+        match=[matchers.query_param_matcher({"page": "3"})],
+        json={
+            "count": 9,
+            "number": 1,
+            "previous": f"{base_url}?page=2",
+            "next": None,
+            "results": [7, 8, 9],
+        },
+    )
+
+    cli = ArkindexClient("t0k3n", base_url="https://dummy.test")
+    assert list(cli.paginate("ListElements", page=2)) == [4, 5, 6, 7, 8, 9]
+    assert len(responses.calls) == 3
+    assert [(level, message) for _module, level, message in caplog.record_tuples] == [
+        (logging.INFO, "Loading page 2 on try 1/5"),
+        (logging.INFO, "Pagination will load a total of 2 pages."),
+        (logging.INFO, "Loading page 3 on try 1/5 - remains 1 page to load."),
+    ]
+
+
+def test_paginate_from_initial_cursor(mock_schema, caplog):
+    caplog.set_level(logging.INFO)
+    base_url = "https://dummy.test/api/v1/process/process_id/elements/"
+
+    responses.add(
+        responses.GET,
+        base_url,
+        match=[matchers.query_param_matcher({"cursor": "DEF", "with_count": "true"})],
+        json={
+            "count": 7,
+            "previous": f"{base_url}?cursor=ABC",
+            "next": f"{base_url}?cursor=GHI",
+            "results": [4, 5, 6],
+        },
+    )
+    responses.add(
+        responses.GET,
+        base_url,
+        match=[matchers.query_param_matcher({"cursor": "GHI"})],
+        json={
+            "count": 7,
+            "previous": f"{base_url}?cursor=ABC",
+            "next": None,
+            "results": [7],
+        },
+    )
+    cli = ArkindexClient("t0k3n", base_url="https://dummy.test")
+    assert list(cli.paginate("ListProcessElements", id="process_id", cursor="DEF")) == [
+        4,
+        5,
+        6,
+        7,
+    ]
+    assert len(responses.calls) == 3
+    assert [(level, message) for _module, level, message in caplog.record_tuples] == [
+        (logging.INFO, "Loading page DEF on try 1/5"),
+        (logging.INFO, "Pagination will load a maximum of 3 pages"),
+        (
+            logging.INFO,
+            "Loading cursor GHI on try 1/5 - remains a maximum of 2 pages to load.",
+        ),
+    ]

arkindex_client-1.2.0/tests/test_request.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+from arkindex.exceptions import ErrorResponse
+
+
+def test_request_no_more_retries(responses, dummy_client):
+    # First call is an error
+    responses.add(
+        responses.POST,
+        "https://dummy.test/api/v1/user/login/",
+        status=502,
+    )
+
+    dummy_client.request.retry.wait = 0
+
+    # There should be 5 retries
+    max_retries = 5
+
+    with pytest.raises(ErrorResponse):
+        dummy_client.login("user@user.user", "Pa$$w0rd")
+
+    assert len(responses.calls) == max_retries
+    assert [call.request.url for call in responses.calls] == [
+        "https://dummy.test/api/v1/user/login/",
+    ] * max_retries

arkindex-client-1.1.4/VERSION

@@ -1 +0,0 @@
-1.1.4

arkindex-client-1.1.4/apistar/__init__.py

@@ -1,9 +0,0 @@
-# -*- coding: utf-8 -*-
-import warnings
-
-warnings.warn(
-    "The Arkindex API client no longer depends on APIStar. "
-    "Please update your `apistar` imports to use the `arkindex` package.",
-    FutureWarning,
-    stacklevel=2,
-)

arkindex-client-1.1.4/apistar/exceptions.py

@@ -1,13 +0,0 @@
-# -*- coding: utf-8 -*-
-import warnings
-
-from arkindex.exceptions import ErrorResponse
-
-__all__ = ["ErrorResponse"]
-
-warnings.warn(
-    "The Arkindex API client no longer depends on APIStar. "
-    "Please update your `apistar.exceptions` imports to use the `arkindex.exceptions` module.",
-    FutureWarning,
-    stacklevel=2,
-)

arkindex-client-1.1.4/requirements-docs.txt

@@ -1,3 +0,0 @@
-black==24.2.0
-mkdocs-autorefs==1.0.1
-mkdocs-material==9.5.10