loxo-cli 0.2.0__tar.gz → 0.2.2__tar.gz

{loxo_cli-0.2.0 → loxo_cli-0.2.2}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.2.2]
+
+### Fixed
+
+- `loxo ref custom-fields` (and `job-types`, `person-types`) no longer hammer the
+  API into rate-limiting (HTTP 429). These reference endpoints return their full
+  list in one response and ignore the `after_id` cursor, so the keyset paginator
+  looped forever. The paginator now stops when the cursor stops advancing, and
+  these endpoints are fetched in a single request.
+- `loxo ref activity-types` no longer fails: the `activity_types` endpoint
+  rejects `after_id` with HTTP 422, so it is now fetched without a cursor.
+- `loxo ref lists` now works. It targets the correct `person_lists` endpoint
+  (the previous `lists` path returned 404).
+
+## [0.2.1]
+
+### Fixed
+
+- `loxo --version` now reports the actual installed version (derived from package
+  metadata) instead of a hardcoded string that could drift. (0.2.0 misreported
+  itself as 0.1.0.)
+
 ## [0.2.0]
 
 ### Added

{loxo_cli-0.2.0 → loxo_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loxo-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: Unofficial command-line interface for the Loxo recruiting ATS/CRM API
 Project-URL: Homepage, https://github.com/alphaomegateam/loxo-cli
 License: MIT

{loxo_cli-0.2.0 → loxo_cli-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "loxo-cli"
-version = "0.2.0"
+version = "0.2.2"
 description = "Unofficial command-line interface for the Loxo recruiting ATS/CRM API"
 readme = "README.md"
 license = { text = "MIT" }

loxo_cli-0.2.2/src/loxo_cli/__init__.py

@@ -0,0 +1,10 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    # Single source of truth: the installed distribution's metadata (driven by
+    # pyproject's version), so `loxo --version` can never drift from the release.
+    __version__ = version("loxo-cli")
+except PackageNotFoundError:  # running from a source tree without an install
+    __version__ = "0.0.0+dev"
+
+__all__ = ["__version__"]

{loxo_cli-0.2.0 → loxo_cli-0.2.2}/src/loxo_cli/commands/ref.py

@@ -9,47 +9,59 @@ ref_app = typer.Typer(help="Reference data lookups. Unofficial — not affiliate
 COLUMNS = ["id", "name"]
 
 
-def _list_reference(ctx: typer.Context, endpoint: str) -> None:
+def _list_reference(ctx: typer.Context, endpoint: str, *, paginated: bool = True) -> None:
     state = ctx.obj
-    rows = list(paginate(state.client(), endpoint, scheme="after_id"))
+    client = state.client()
+    if paginated:
+        rows = list(paginate(client, endpoint, scheme="after_id"))
+    else:
+        # Several reference endpoints return a fixed, complete list in one
+        # response and don't support keyset pagination: dynamic_fields/job_types/
+        # person_types ignore after_id (driving the paginator loops forever ->
+        # 429), and activity_types rejects after_id with HTTP 422. Fetch once.
+        rows = extract_items(client.get(endpoint), None)
     state.emit(rows, columns=COLUMNS)
 
 
 @ref_app.command("job-types")
 def job_types(ctx: typer.Context) -> None:
-    _list_reference(ctx, "job_types")
+    _list_reference(ctx, "job_types", paginated=False)
 
 
 @ref_app.command("activity-types")
 def activity_types(ctx: typer.Context) -> None:
-    _list_reference(ctx, "activity_types")
+    _list_reference(ctx, "activity_types", paginated=False)
 
 
 @ref_app.command("source-types")
 def source_types(ctx: typer.Context) -> None:
+    # source_types genuinely keyset-paginates (honors after_id); keep paging.
     _list_reference(ctx, "source_types")
 
 
 @ref_app.command("person-types")
 def person_types(ctx: typer.Context) -> None:
-    _list_reference(ctx, "person_types")
+    _list_reference(ctx, "person_types", paginated=False)
 
 
 @ref_app.command("lists")
 def lists(ctx: typer.Context) -> None:
-    _list_reference(ctx, "lists")
+    """List the agency's people lists."""
+    # The endpoint is person_lists (GET /lists is 404). It returns the full list
+    # in one response and ignores after_id, so fetch once.
+    _list_reference(ctx, "person_lists", paginated=False)
 
 
 @ref_app.command("custom-fields")
 def custom_fields(ctx: typer.Context) -> None:
     """List agency custom (dynamic) field definitions."""
-    _list_reference(ctx, "dynamic_fields")
+    _list_reference(ctx, "dynamic_fields", paginated=False)
 
 
 @ref_app.command("dynamic-fields", hidden=True)
 def dynamic_fields_alias(ctx: typer.Context) -> None:
     """Alias of custom-fields."""
-    _list_reference(ctx, "dynamic_fields")
+    _list_reference(ctx, "dynamic_fields", paginated=False)
 
 
 @ref_app.command("hierarchies")

{loxo_cli-0.2.0 → loxo_cli-0.2.2}/src/loxo_cli/pagination.py

@@ -85,9 +85,22 @@ def paginate(
             items = extract_items(data, items_key)
             if not items:
                 return
+            next_after_id = items[-1].get("id") if isinstance(items[-1], dict) else None
+            # If the endpoint ignored after_id and returned the same page again
+            # (some reference endpoints, e.g. dynamic_fields, return a fixed list
+            # and ignore the cursor), the cursor won't advance. Stop without
+            # re-yielding the duplicate page. Without this guard those endpoints
+            # loop forever, hammering the API until it rate-limits us (429).
+            # Only applies once a cursor has actually been sent: on the first
+            # page after_id is None, and a no-id last item there is a legitimate
+            # single, complete page that must still be yielded.
+            if after_id is not None and next_after_id == after_id:
+                return
             yield from items
-            after_id = items[-1].get("id") if isinstance(items[-1], dict) else None
-            if after_id is None:
+            # Last item has no id -> can't build a next cursor, so this is the
+            # final page.
+            if next_after_id is None:
                 return
+            after_id = next_after_id
     else:
         raise ValueError(f"Unknown pagination scheme: {scheme}")

loxo_cli-0.2.2/tests/test_cmd_ref.py

@@ -0,0 +1,94 @@
+import json
+
+import httpx
+import respx
+from typer.testing import CliRunner
+
+from loxo_cli.__main__ import app
+
+runner = CliRunner()
+ENV = {"LOXO_API_KEY": "k", "LOXO_API_SLUG": "acme"}
+
+
+@respx.mock
+def test_ref_job_types_single_fetch():
+    # job_types ignores after_id (returns its full list every call), so the
+    # command fetches once instead of driving the keyset paginator.
+    route = respx.get("https://app.loxo.co/api/acme/job_types").mock(
+        return_value=httpx.Response(
+            200, json=[{"id": 1, "name": "Perm"}, {"id": 2, "name": "Temp"}]
+        )
+    )
+    result = runner.invoke(app, ["--json", "ref", "job-types"], env=ENV)
+    assert [x["name"] for x in json.loads(result.stdout)] == ["Perm", "Temp"]
+    assert route.call_count == 1
+
+
+@respx.mock
+def test_ref_activity_types_single_fetch_no_after_id():
+    # activity_types REJECTS after_id with HTTP 422. The command must not send
+    # it: a single fetch with no after_id param, and never a second request.
+    def handler(request):
+        assert "after_id" not in request.url.params, "must not send after_id to activity_types"
+        return httpx.Response(200, json=[{"id": 9, "name": "Call"}])
+
+    route = respx.get("https://app.loxo.co/api/acme/activity_types").mock(side_effect=handler)
+    result = runner.invoke(app, ["--json", "ref", "activity-types"], env=ENV)
+    assert result.exit_code == 0
+    assert [x["name"] for x in json.loads(result.stdout)] == ["Call"]
+    assert route.call_count == 1
+
+
+@respx.mock
+def test_ref_source_types_still_paginates():
+    # source_types genuinely honors after_id; the command must keep paging.
+    route = respx.get("https://app.loxo.co/api/acme/source_types").mock(
+        side_effect=[
+            httpx.Response(200, json=[{"id": 10, "name": "A"}, {"id": 11, "name": "B"}]),
+            httpx.Response(200, json=[{"id": 12, "name": "C"}]),
+            httpx.Response(200, json=[]),
+        ]
+    )
+    result = runner.invoke(app, ["--json", "ref", "source-types"], env=ENV)
+    assert [x["name"] for x in json.loads(result.stdout)] == ["A", "B", "C"]
+    assert route.call_count == 3
+
+
+@respx.mock
+def test_ref_custom_fields_single_fetch():
+    # dynamic_fields is a flat config list that ignores after_id, so the command
+    # fetches it exactly once rather than driving the keyset paginator (which the
+    # endpoint would loop forever, causing 429s). A single non-empty response is
+    # all the endpoint ever returns.
+    route = respx.get("https://app.loxo.co/api/acme/dynamic_fields").mock(
+        return_value=httpx.Response(200, json=[{"id": 1, "name": "custom_text_3"}])
+    )
+    result = runner.invoke(app, ["--json", "ref", "custom-fields"], env=ENV)
+    assert json.loads(result.stdout)[0]["name"] == "custom_text_3"
+    assert route.call_count == 1
+
+
+@respx.mock
+def test_ref_lists_uses_person_lists_endpoint():
+    # `ref lists` maps to the person_lists endpoint (GET /lists 404s). It returns
+    # the full list in one response and ignores after_id -> single fetch.
+    lists_route = respx.get("https://app.loxo.co/api/acme/lists").mock(
+        return_value=httpx.Response(404, json={"status": 404, "error": "Not Found"})
+    )
+    person_lists_route = respx.get("https://app.loxo.co/api/acme/person_lists").mock(
+        return_value=httpx.Response(200, json=[{"id": 5, "name": "Hot Leads"}])
+    )
+    result = runner.invoke(app, ["--json", "ref", "lists"], env=ENV)
+    assert result.exit_code == 0
+    assert [x["name"] for x in json.loads(result.stdout)] == ["Hot Leads"]
+    assert person_lists_route.call_count == 1
+    assert lists_route.call_count == 0  # must not hit the 404 path
+
+
+@respx.mock
+def test_ref_hierarchies():
+    respx.get("https://app.loxo.co/api/acme/dynamic_fields/7/hierarchies").mock(
+        return_value=httpx.Response(200, json={"hierarchies": [{"id": 1, "name": "L1"}]})
+    )
+    result = runner.invoke(app, ["--json", "ref", "hierarchies", "7"], env=ENV)
+    assert json.loads(result.stdout)[0]["name"] == "L1"

{loxo_cli-0.2.0 → loxo_cli-0.2.2}/tests/test_pagination.py

@@ -102,3 +102,20 @@ def test_after_id_pagination():
     with LoxoClient(SETTINGS) as client:
         items = list(paginate(client, "source_types", scheme="after_id"))
     assert [i["id"] for i in items] == [10, 11, 12]
+
+
+@respx.mock
+def test_after_id_stops_when_cursor_does_not_advance():
+    # Some reference endpoints (e.g. dynamic_fields) return a fixed, complete
+    # list and IGNORE the after_id query param — so they hand back the same
+    # non-empty page on every request. The after_id paginator must detect the
+    # non-advancing cursor and stop, instead of looping forever and getting
+    # rate-limited (429). It must also not re-yield the duplicate page.
+    base = "https://app.loxo.co/api/acme/dynamic_fields"
+    same = [{"id": 1, "name": "custom_text_3"}, {"id": 2, "name": "custom_hierarchy_5"}]
+    route = respx.get(base).mock(return_value=httpx.Response(200, json=same))
+    with LoxoClient(SETTINGS) as client:
+        items = list(paginate(client, "dynamic_fields", scheme="after_id"))
+    assert [i["id"] for i in items] == [1, 2]
+    # One real page + one probe that proves the cursor didn't advance, then stop.
+    assert route.call_count == 2

{loxo_cli-0.2.0 → loxo_cli-0.2.2}/uv.lock

@@ -274,7 +274,7 @@ wheels = [
 
 [[package]]
 name = "loxo-cli"
-version = "0.2.0"
+version = "0.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

loxo_cli-0.2.0/src/loxo_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"

loxo_cli-0.2.0/tests/test_cmd_ref.py

@@ -1,43 +0,0 @@
-import json
-
-import httpx
-import respx
-from typer.testing import CliRunner
-
-from loxo_cli.__main__ import app
-
-runner = CliRunner()
-ENV = {"LOXO_API_KEY": "k", "LOXO_API_SLUG": "acme"}
-
-
-@respx.mock
-def test_ref_job_types_after_id():
-    respx.get("https://app.loxo.co/api/acme/job_types").mock(
-        side_effect=[
-            httpx.Response(200, json=[{"id": 1, "name": "Perm"}, {"id": 2, "name": "Temp"}]),
-            httpx.Response(200, json=[]),
-        ]
-    )
-    result = runner.invoke(app, ["--json", "ref", "job-types"], env=ENV)
-    assert [x["name"] for x in json.loads(result.stdout)] == ["Perm", "Temp"]
-
-
-@respx.mock
-def test_ref_custom_fields():
-    respx.get("https://app.loxo.co/api/acme/dynamic_fields").mock(
-        side_effect=[
-            httpx.Response(200, json=[{"id": 1, "name": "custom_text_3"}]),
-            httpx.Response(200, json=[]),
-        ]
-    )
-    result = runner.invoke(app, ["--json", "ref", "custom-fields"], env=ENV)
-    assert json.loads(result.stdout)[0]["name"] == "custom_text_3"
-
-
-@respx.mock
-def test_ref_hierarchies():
-    respx.get("https://app.loxo.co/api/acme/dynamic_fields/7/hierarchies").mock(
-        return_value=httpx.Response(200, json={"hierarchies": [{"id": 1, "name": "L1"}]})
-    )
-    result = runner.invoke(app, ["--json", "ref", "hierarchies", "7"], env=ENV)
-    assert json.loads(result.stdout)[0]["name"] == "L1"