agilicus 1.304.3__py3-none-any.whl → 1.306.0__py3-none-any.whl

agilicus/pagination/auto_iterator.py

@@ -0,0 +1,173 @@
+"""
+AutoIterator for paginating API client list functions.
+"""
+
+import json
+from agilicus_api.exceptions import ApiException
+
+_page_on_preference = ["name", "created", "id"]
+_default_page_on = "id"
+
+
+def get_page_on(list_function):
+    """
+    tries to figure out the pagination key to use based on the endpoint:
+     - If it's an enum, uses the preferred one in the list, otherwise the first
+     - If it's not an enum, just tries the 'default', which is id.
+    """
+    # yes, the key here is a tuple or some reason
+    result = list(list_function.allowed_values.get(("page_on",), {}).values())
+    if not result and "page_on" in list_function.params_map["all"]:
+        return [_default_page_on]
+    return result
+
+
+def _determine_page_on(list_function):
+    page_on_list = get_page_on(list_function)
+    if not page_on_list:
+        raise NotImplementedError("pagination not implemented on this endpoint")
+    for page_on in _page_on_preference:
+        if page_on in page_on_list:
+            return [page_on]
+
+    return [page_on_list[0]]
+
+
+def patch_endpoint(list_function):
+    setattr(list_function, "auto_paging_iter", AutoIteratorWrapper(list_function))
+
+
+class AutoIteratorWrapper:
+    def __init__(self, list_function):
+        self.list_function = list_function
+
+    def __call__(self, *args, limit=None, page_size=100, page_sort=None, **kwargs):
+        return AutoIterator(
+            self.list_function, limit, page_size, page_sort, *args, **kwargs
+        )
+
+
+class AutoIterator:
+    def __init__(
+        self, list_function, limit, page_size, page_sort, *args, page_on=None, **kwargs
+    ):
+        """
+        Initializes the AutoIterator.
+
+        :param list_function: The API client list function to paginate.
+        :param args: Positional arguments to pass to the list_function.
+        :param kwargs: Keyword arguments to pass to the list_function.
+        """
+        self._list_function = list_function
+        self._args = args
+        self._kwargs = kwargs
+        self.page_sort = page_sort or []
+        self.limit = limit
+        self.page_size = page_size
+        self.configured_page_on = page_on or _determine_page_on(self._list_function)
+        self._reset()
+
+    def _reset(self):
+        self._total_items = 0
+        self._page_on = self.configured_page_on
+        self._next_page = []
+        self._has_more = True
+        self._current_page_items = []
+
+    def __iter__(self):
+        """
+        Returns the iterator object itself.
+        """
+        return self
+
+    def __next__(self):
+        """
+        Fetches the next item from the paginated results.
+        """
+        if not self._current_page_items and self._has_more:
+            self._fetch_next_page()
+
+        if self._current_page_items:
+            return self._current_page_items.pop(0)
+        else:
+            raise StopIteration
+
+    def _get_page_list(self, response):
+        for key in response.attribute_map:
+            if isinstance(response.get(key), list):
+                return response.get(key)
+        return []
+
+    def _fetch_next_page(self):
+        limit = self.page_size
+        if self.limit is not None:
+            limit = min(limit, self.limit - self._total_items)
+
+        try:
+            response = self._list_function(
+                page_on=self._page_on,
+                page_at_key=self._next_page,
+                limit=limit,
+                page_sort=self.page_sort,
+                **self._kwargs,
+            )
+        except ApiException as exc:
+            if exc.status != 400:
+                raise
+
+            _handle_page_failure(exc.body)
+            # Shut up the linter, which thinks the above doesn't always throw even
+            # though it does
+            assert False
+
+        self._current_page_items = self._get_page_list(response)
+        self._total_items = self._total_items + len(self._current_page_items)
+        page_info = response.page_info
+        if (
+            not page_info
+            or not self._current_page_items
+            or (self.limit and self._total_items >= self.limit)
+        ):
+            self._has_more = False
+            return
+
+        self._next_page = page_info.page_at_key
+        self._page_on = page_info.page_on.value
+
+    # Additional functionality when interacted with as an object
+    def all(self):
+        """
+        Returns all items by iterating through all pages.
+        """
+        all_items = []
+        for item in self:
+            all_items.append(item)
+        return all_items
+
+    def first(self):
+        """
+        Returns the first item, or None if no items.
+        """
+        self._reset()
+        try:
+            return next(self)
+        except StopIteration:
+            return None
+
+    def __repr__(self):
+        return f"<AutoIterator for {self._list_function.__name__}>"
+
+
+def _handle_page_failure(body):
+    if not body:
+        raise
+    result = {}
+    try:
+        result = json.loads(body)
+    except Exception:
+        pass
+    error_message = result.get("error_message", "")
+    if "pagination key" not in error_message:
+        raise
+
+    raise NotImplementedError("Pagination not implemented on this key") from None

agilicus/pagination/input.py

@@ -2,4 +2,7 @@ def normalize_page_args(kwargs):
     page_sort = kwargs.get("page_sort")
     if isinstance(page_sort, tuple):
         kwargs["page_sort"] = list(page_sort)
+    page_on = kwargs.get("page_on")
+    if isinstance(page_on, tuple):
+        kwargs["page_on"] = list(page_on)
     return kwargs

agilicus/patches.py

@@ -5,6 +5,8 @@ import certifi
 from .agilicus_api.api_client import ApiClient
 from .agilicus_api.configuration import Configuration
 
+from agilicus.pagination.auto_iterator import get_page_on, patch_endpoint
+
 
 class _ApiClientWrapper(ApiClient):
     def __init__(self, configuration: Configuration = None, **kwargs):
@@ -43,3 +45,18 @@ def patched_api_client():
 class _Response:
     def __init__(self, data):
         self.data = data
+
+
+def patch_endpoint_class(endpoint_class):
+    """
+    patches the Endpoint class to inject the AutoIterator into itself if needed.
+    """
+    original_init = endpoint_class.__init__
+
+    def init_wrapper(self, *args, **kwargs):
+        original_init(self, *args, **kwargs)
+        if not get_page_on(self):
+            return
+        patch_endpoint(self)
+
+    endpoint_class.__init__ = init_wrapper

agilicus/resources.py

@@ -113,7 +113,7 @@ def bulk_delete_permission(ctx, **kwargs):
     )
 
 
-def query_resources(ctx, org_id=None, **kwargs):
+def query_resources(ctx, org_id=None, get_all=False, limit=None, **kwargs):
     org_id = get_org_from_input_or_ctx(ctx, org_id=org_id)
     token = context.get_token(ctx)
     apiclient = context.get_apiclient(ctx, token)
@@ -121,10 +121,13 @@ def query_resources(ctx, org_id=None, **kwargs):
     params = {}
     update_if_not_none(params, kwargs)
     params = normalize_page_args(params)
-    query_results = apiclient.resources_api.list_resources(**params)
-    if query_results:
-        return query_results.resources
-    return []
+    if not get_all:
+        if limit is None:
+            limit = 500
+        return apiclient.resources_api.list_resources(limit=limit, **params).resources
+    return apiclient.resources_api.list_resources.auto_paging_iter(
+        limit=limit, **params
+    ).all()
 
 
 def format_resources(ctx, resources, show_columns=None, reset_columns=None):

agilicus/ssh.py

@@ -21,13 +21,23 @@ from .resource_helpers import map_resource_published, standard_page_fields
 page_fields = standard_page_fields
 
 
-def list_ssh_resources(ctx, **kwargs):
+def list_ssh_resources(ctx, get_all=False, limit=None, **kwargs):
     apiclient = context.get_apiclient_from_ctx(ctx)
     update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
     params = strip_none(kwargs)
     params = normalize_page_args(params)
-    query_results = apiclient.app_services_api.list_ssh_resources(**params)
-    return query_results.ssh_resources
+    if not get_all:
+        if limit is None:
+            limit = 500
+        return apiclient.app_services_api.list_ssh_resources(
+            limit=limit, **params
+        ).ssh_resources
+    return [
+        x
+        for x in apiclient.app_services_api.list_ssh_resources.auto_paging_iter(
+            limit=limit, **params
+        )
+    ]
 
 
 def add_ssh_resource(ctx, port, **kwargs):

agilicus/tests/pagination/test_auto_iterator.py

@@ -0,0 +1,340 @@
+import pytest
+from unittest.mock import Mock
+from agilicus.pagination.auto_iterator import (
+    AutoIterator,
+    AutoIteratorWrapper,
+    get_page_on,
+    _determine_page_on,
+    patch_endpoint,
+    _handle_page_failure,
+)
+from agilicus_api.exceptions import ApiException
+from agilicus import ListSSHResourcesResponse
+from agilicus_api.api_client import Endpoint
+
+
+class MockPageInfo:
+    def __init__(self, page_at_key, page_on_value):
+        self.page_at_key = page_at_key
+        self.page_on = Mock(value=page_on_value)
+
+
+class MockResponse:
+    def __init__(self, items, page_at_key=None, page_on_value=None):
+        self.items = items
+        self.attribute_map = {"items": "list[object]"}
+        self.page_info = (
+            MockPageInfo(page_at_key, page_on_value)
+            if page_at_key and page_on_value
+            else None
+        )
+
+    def get(self, key):
+        if key == "items":
+            return self.items
+        return None
+
+
+class MockItem:
+    def __init__(self, name, index):
+        self.name = name
+        self.id = index
+
+
+class MockListFunction:
+    def __init__(self, items_per_page, total_items, page_on_allowed=None):
+        self._all_items = [MockItem(f"item_{i}", i) for i in range(total_items)]
+        self._items_per_page = items_per_page
+        self.call_count = 0
+        self.allowed_values = {}
+        self.params_map = {"all": []}
+        if page_on_allowed is None:
+            page_on_allowed = ["id"]
+        if page_on_allowed:
+            self.allowed_values = {("page_on",): {k: k for k in page_on_allowed}}
+            self.params_map["all"].append("page_on")
+
+    def __call__(
+        self, page_on=None, page_at_key=None, limit=None, page_sort=None, **kwargs
+    ):
+        self.call_count += 1
+        start_index = 0
+        if page_at_key and page_at_key[0] is not None:
+            try:
+                start_index = len(self._all_items)
+                for idx, item in enumerate(self._all_items):
+                    compare_tuple = [getattr(item, key) for key in page_on]
+                    if page_at_key < compare_tuple:
+                        start_index = idx
+                        break
+            except ValueError:
+                start_index = len(self._all_items)
+
+        end_index = min(start_index + limit, len(self._all_items))
+        current_items = self._all_items[start_index:end_index]
+
+        next_page_at_key = None
+        if end_index < len(self._all_items):
+            next_page_at_key = [self._all_items[end_index - 1].id]
+
+        return MockResponse(
+            current_items,
+            page_at_key=next_page_at_key,
+            page_on_value=page_on if page_on else None,
+        )
+
+
+def test_auto_iterator_basic_pagination():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=5)
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    items = list(iterator)
+    assert len(items) == 5
+    assert mock_list_function.call_count == 3  # 5 items, 2 per page = 3 calls (2,2,1)
+    assert [item.name for item in items] == [
+        "item_0",
+        "item_1",
+        "item_2",
+        "item_3",
+        "item_4",
+    ]
+
+
+def test_auto_iterator_with_limit():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=5)
+    iterator = AutoIterator(mock_list_function, limit=3, page_size=2, page_sort=[])
+
+    items = list(iterator)
+    assert len(items) == 3
+    assert mock_list_function.call_count == 2  # 3 items, 2 per page = 2 calls (2,1)
+    assert [item.name for item in items] == ["item_0", "item_1", "item_2"]
+
+
+def test_auto_iterator_empty_result():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=0)
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    items = list(iterator)
+    assert len(items) == 0
+    assert mock_list_function.call_count == 1
+
+
+def test_auto_iterator_first_method():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=5)
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    first_item = iterator.first()
+    assert first_item.name == "item_0"
+    assert mock_list_function.call_count == 1
+
+    # Calling first again should re-initialize and get the first item again
+    first_item = iterator.first()
+    assert first_item.name == "item_0"
+    assert mock_list_function.call_count == 2
+
+
+def test_auto_iterator_first_method_empty():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=0)
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    first_item = iterator.first()
+    assert first_item is None
+    assert mock_list_function.call_count == 1
+
+
+def test_auto_iterator_all_method():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=5)
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    all_items = iterator.all()
+    assert len(all_items) == 5
+    assert mock_list_function.call_count == 3
+    assert [item.name for item in all_items] == [
+        "item_0",
+        "item_1",
+        "item_2",
+        "item_3",
+        "item_4",
+    ]
+
+
+def test_auto_iterator_all_method_empty():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=0)
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    all_items = iterator.all()
+    assert len(all_items) == 0
+    assert mock_list_function.call_count == 1
+
+
+def test_auto_iterator_wrapper():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=5)
+    wrapper = AutoIteratorWrapper(mock_list_function)
+    iterator = wrapper(limit=3, page_size=2, page_sort=["name"])
+
+    assert isinstance(iterator, AutoIterator)
+    assert iterator.limit == 3
+    assert iterator.page_size == 2
+    assert iterator.page_sort == ["name"]
+
+
+def test_get_page_on_with_allowed_values():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {("page_on",): {"id": "id", "name": "name"}}
+    mock_list_function.params_map = {"all": ["page_on"]}
+    assert get_page_on(mock_list_function) == ["id", "name"]
+
+
+def test_get_page_on_without_allowed_values_but_in_params_map():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {}
+    mock_list_function.params_map = {"all": ["page_on"]}
+    assert get_page_on(mock_list_function) == ["id"]
+
+
+def test_get_page_on_not_in_params_map():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {}
+    mock_list_function.params_map = {"all": []}
+    assert get_page_on(mock_list_function) == []
+
+
+def test_determine_page_on_preference():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {
+        ("page_on",): {"created": "created", "id": "id"}
+    }
+    mock_list_function.params_map = {"all": ["page_on"]}
+    assert _determine_page_on(mock_list_function) == ["created"]
+
+
+def test_determine_page_on_default():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {("page_on",): {"foo": "foo"}}
+    mock_list_function.params_map = {"all": ["page_on"]}
+    assert _determine_page_on(mock_list_function) == ["foo"]
+
+
+def test_determine_page_on_not_implemented():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {}
+    mock_list_function.params_map = {"all": []}
+    with pytest.raises(NotImplementedError):
+        _determine_page_on(mock_list_function)
+
+
+def test_patch_endpoint():
+    mock_list_function = Mock()
+    patch_endpoint(mock_list_function)
+    assert hasattr(mock_list_function, "auto_paging_iter")
+    assert isinstance(mock_list_function.auto_paging_iter, AutoIteratorWrapper)
+
+
+def test_handle_page_failure_pagination_key_error():
+    exc = ApiException(status=400, reason="Bad Request", http_resp=Mock())
+    exc.body = '{"error_message": "Invalid pagination key"}'
+    with pytest.raises(
+        NotImplementedError, match="Pagination not implemented on this key"
+    ):
+        _handle_page_failure(exc.body)
+
+
+def test_handle_page_failure_other_400_error():
+    exc = ApiException(status=400, reason="Bad Request", http_resp=Mock())
+    exc.body = '{"error_message": "Some other error"}'
+    with pytest.raises(ApiException):
+        try:
+            raise exc
+        except Exception as exc:
+            _handle_page_failure(exc.body)
+
+
+def test_handle_page_failure_no_body():
+    exc = ApiException(status=400, reason="Bad Request", http_resp=Mock())
+    exc.body = None
+    with pytest.raises(ApiException):
+        try:
+            raise exc
+        except Exception as exc:
+            _handle_page_failure(exc.body)
+
+
+def test_handle_page_failure_invalid_json():
+    exc = ApiException(status=400, reason="Bad Request", http_resp=Mock())
+    exc.body = "invalid json"
+    with pytest.raises(ApiException):
+        try:
+            raise exc
+        except Exception as exc:
+            _handle_page_failure(exc.body)
+
+
+def test_auto_iterator_api_exception_other_status():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {("page_on",): {"foo": "foo"}}
+    mock_list_function.params_map = {"all": ["page_on"]}
+    mock_list_function.side_effect = ApiException(
+        status=500, reason="Internal Server Error"
+    )
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    with pytest.raises(ApiException):
+        list(iterator)
+
+
+def test_auto_iterator_repr():
+    mock_list_function = Mock(
+        __name__="mock_list_function",
+        allowed_values={("page_on",): {"id": "id"}},
+        params_map={"all": ["page_on"]},
+    )
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+    assert repr(iterator) == "<AutoIterator for mock_list_function>"
+
+
+def test_auto_patch_endpoint():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=5)
+
+    def wrap_list(*args, **kwargs):
+        return mock_list_function(**kwargs)
+
+    foo = Endpoint(
+        settings={
+            "response_type": (ListSSHResourcesResponse,),
+            "auth": ["token-valid"],
+            "endpoint_path": "/v1/ssh_resources",
+            "operation_id": "list_ssh_resources",
+            "http_method": "GET",
+            "servers": None,
+        },
+        params_map={
+            "all": [
+                "page_on",
+                "page_at_key",
+                "page_sort",
+                "search_direction",
+            ],
+            "required": [],
+            "nullable": [],
+            "enum": [
+                "page_sort",
+                "search_direction",
+            ],
+            "validation": [
+                "name",
+                "limit",
+            ],
+        },
+        root_map={
+            "validations": [],
+            "allowed_values": {("page_on,"): ["name"]},
+            "openapi_types": {},
+            "attribute_map": {},
+            "location_map": {},
+            "collection_format_map": {},
+        },
+        callable=wrap_list,
+    )
+
+    assert foo.auto_paging_iter is not None
+    assert next(foo.auto_paging_iter()).name == "item_0"

{agilicus-1.304.3.dist-info → agilicus-1.306.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agilicus
-Version: 1.304.3
+Version: 1.306.0
 Summary: Agilicus SDK
 License: MIT
 Author: Agilicus Devs