feat: Add allow_deletes option to QuickbaseTableClient (#56)

Also makes the QuickbaseApiClient rf (RequestFactory) attribute
private, and removes unused "default_select" from
QuickbaseTableClient (which was accidentally lingering). Lastly,
forwards arguments from the .client factory method in
QuickbaseTable classes.

Author: tkutcher

CHANGELOG.rst

@@ -2,6 +2,14 @@
 CHANGELOG
 ==========
 
+`0.6.0`_ (2022-5-2)
+---------------------
+
+* Add ``allow_deletes`` option to ``QuickbaseTableClient`` (`#56`_)
+* Forward kwargs from ``QuickbaseTable.client`` to ``QuickbaseTableClient`` (`#56`_)
+* Make the ``rf`` prop of ``QuickbaseApiClient`` private as it is not really part of the API
+
+
 `0.5.2`_ (2022-4-14)
 ---------------------
 
@@ -74,6 +82,9 @@ CHANGELOG
 .. _`0.3.1`: https://github.com/tkutcher/quickbase-client/releases/tag/v0.3.1
 .. _`0.4.0`: https://github.com/tkutcher/quickbase-client/releases/tag/v0.4.0
 .. _`0.5.0`: https://github.com/tkutcher/quickbase-client/releases/tag/v0.5.0
+.. _`0.5.1`: https://github.com/tkutcher/quickbase-client/releases/tag/v0.5.1
+.. _`0.5.2`: https://github.com/tkutcher/quickbase-client/releases/tag/v0.5.2
+.. _`0.6.0`: https://github.com/tkutcher/quickbase-client/releases/tag/v0.6.0
 
 
 ..
@@ -91,6 +102,7 @@ CHANGELOG
 .. _`#52`: https://github.com/tkutcher/quickbase-client/issues/52
 .. _`#53`: https://github.com/tkutcher/quickbase-client/issues/53
 .. _`#54`: https://github.com/tkutcher/quickbase-client/issues/54
+.. _`#56`: https://github.com/tkutcher/quickbase-client/issues/56
 
 
 ..

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "quickbase-client"
-version = "0.5.3"
+version = "0.6.0"
 description = "A Quickbase Python API Client Generator"
 authors = ["Tim Kutcher <tim@tkutcher.com>"]
 maintainers = ["Tim Kutcher <tim@tkutcher.com>"]

src/quickbase_client/client/api.py

@@ -21,49 +21,49 @@ class QuickbaseApiClient(object):
     """
 
     def __init__(self, user_token, realm_hostname, agent="python", allow_deletes=False):
-        self.rf = QuickbaseRequestFactory(
+        self._rf = QuickbaseRequestFactory(
             user_token, realm_hostname, agent, allow_deletes=allow_deletes
         )
         self.legacy_api = QuickbaseLegacyApiClient(user_token, realm_hostname)
 
     def request(self, *args, **kwargs):
-        return self.rf.make_request(*args, **kwargs)
+        return self._rf.make_request(*args, **kwargs)
 
     # FUTURE - Can add more of these methods, even refactoring in to separate classes
     #   for each main endpoint. Initially just including some of the more common
     #   functions.
 
     def get_app(self, app_id):
-        return self.rf.get(f"/apps/{app_id}")
+        return self._rf.get(f"/apps/{app_id}")
 
     def get_tables_for_app(self, app_id):
-        return self.rf.get("/tables", params={"appId": app_id})
+        return self._rf.get("/tables", params={"appId": app_id})
 
     def get_table(self, app_id, table_id):
-        return self.rf.get(f"/tables/{table_id}", params={"appId": app_id})
+        return self._rf.get(f"/tables/{table_id}", params={"appId": app_id})
 
     def get_fields_for_table(self, table_id):
-        return self.rf.get("/fields", params={"tableId": table_id})
+        return self._rf.get("/fields", params={"tableId": table_id})
 
     def get_field(self, field_id, table_id):
-        return self.rf.get(f"/fields/{field_id}", params={"tableId": table_id})
+        return self._rf.get(f"/fields/{field_id}", params={"tableId": table_id})
 
     def get_reports_for_table(self, table_id):
-        return self.rf.get("/reports", params={"tableId": table_id})
+        return self._rf.get("/reports", params={"tableId": table_id})
 
     def get_report(self, report_id, table_id):
-        return self.rf.get(f"/reports/{report_id}", params={"tableId": table_id})
+        return self._rf.get(f"/reports/{report_id}", params={"tableId": table_id})
 
     def run_report(self, report_id, table_id, skip=None, top=None):
         payload = make_payload({"skip": skip, "top": top})
-        return self.rf.post(
+        return self._rf.post(
             f"/reports/{report_id}/run", params={"tableId": table_id}, data=payload
         )
 
     def add_records(
         self, table_id, data=None, merge_field_id=None, fields_to_return=None
     ):
-        return self.rf.post(
+        return self._rf.post(
             "/records",
             data=make_payload(
                 {
@@ -84,7 +84,7 @@ def query(
         group_by=None,
         options=None,
     ):
-        return self.rf.post(
+        return self._rf.post(
             "/records/query",
             data=make_payload(
                 {

src/quickbase_client/client/table_client.py

@@ -39,6 +39,11 @@ class QuickbaseTableClient(object):
     :param normalize_unicode:
         Whether the JSON Serializer should normalize accented characters so that they
         can be encoded in Quickbase.
+
+    :param bool allow_deletes:
+        Whether the client should be allowed to perform delete requests. Defaulted to
+        False for now. But note that this is subject to change in 1.0 if there is a
+        different general preference.
     """
 
     def __init__(
@@ -47,14 +52,18 @@ def __init__(
         user_token,
         agent="python",
         normalize_unicode=True,
-        default_select=None,
+        allow_deletes=False,
     ):
         self.table = table
         self.serializer = RecordJsonSerializer(
             table_cls=self.table, normalize_unicode=normalize_unicode
         )
-        self.api = QuickbaseApiClient(user_token, table.realm_hostname(), agent=agent)
-        self._default_select = default_select
+        self.api = QuickbaseApiClient(
+            user_token,
+            table.realm_hostname(),
+            agent=agent,
+            allow_deletes=allow_deletes,
+        )
 
     @property
     def app_id(self):

src/quickbase_client/orm/table.py

@@ -113,14 +113,15 @@ def get_attr_from_fid(cls, fid: int):
         return cls.__fidmap__[fid]  # noqa
 
     @classmethod
-    def client(cls, user_token: str):
+    def client(cls, user_token: str, **kwargs):
         """Factory method to create a :class:`~QuickbaseTableClient` for this table.
 
         :param user_token: The user token for authentication.
+        :param kwargs: Forwarded to :class:`~QuickbaseTableClient`.
         """
         from quickbase_client.client.table_client import QuickbaseTableClient
 
-        return QuickbaseTableClient(cls, user_token)
+        return QuickbaseTableClient(cls, user_token, **kwargs)
 
 
 QuickBaseTable = QuickbaseTable  # alias - TODO - delete in future.

src/quickbase_client/query/query_base.py

@@ -4,7 +4,7 @@ class QuickbaseQuery(object):
     .. note::
         Current alias of ``QuickbaseQuery`` for backwards compatibility.
 
-    :param str where: The where string, e.g. ``"{7.EX.'18'}"``
+    :param Optional[str] where: The where string, e.g. ``"{7.EX.'18'}"``
 
     :param dict options:
         Additional options to pass to the Quickbase runQuery endpoint.

tests/test_client/test_api.py

@@ -12,14 +12,14 @@ def test_makes_request_factory(self):
         client = QuickbaseApiClient(
             user_token="foo", realm_hostname="dicorp.quickbase.com"
         )
-        assert client.rf.user_token == "foo"
-        assert client.rf.realm_hostname == "dicorp.quickbase.com"
+        assert client._rf.user_token == "foo"
+        assert client._rf.realm_hostname == "dicorp.quickbase.com"
 
     def test_request_alias(self, mocker):
         client = QuickbaseApiClient(
             user_token="foo", realm_hostname="dicorp.quickbase.com"
         )
-        spy = mocker.spy(client.rf.session, "request")
+        spy = mocker.spy(client._rf.session, "request")
         client.request(method="POST", endpoint="/blah")
         _, kwargs = spy.call_args
         assert kwargs["method"] == "POST"
@@ -30,7 +30,7 @@ def test_class_is_aliases(self, mocker):
         client = QuickBaseApiClient(
             user_token="foo", realm_hostname="dicorp.quickbase.com"
         )
-        spy = mocker.spy(client.rf.session, "request")
+        spy = mocker.spy(client._rf.session, "request")
         client.request(method="POST", endpoint="/blah")
         _, kwargs = spy.call_args
         assert kwargs["method"] == "POST"
@@ -39,7 +39,7 @@ def test_query(self, mocker):
         client = QuickbaseApiClient(
             user_token="foo", realm_hostname="dicorp.quickbase.com"
         )
-        spy = mocker.spy(client.rf.session, "request")
+        spy = mocker.spy(client._rf.session, "request")
         client.query(table_id="aaaaaa", where_str="{'18'.EX.19}")
         _, kwargs = spy.call_args
         assert "{'18'.EX.19}" in json.dumps(kwargs["json"])

tests/test_client/test_table_client.py

@@ -44,7 +44,7 @@ def test_makes_api_request_to_correct_url(
     )
     def test_request_includes_proper_headers(self, mocker, debugs_table, header, val):
         client = QuickbaseTableClient(debugs_table, user_token="myusertoken")
-        spy = mocker.spy(client.api.rf.session, "request")
+        spy = mocker.spy(client.api._rf.session, "request")
         client.get_table()
         args, kwargs = spy.call_args
         headers = kwargs["headers"]
@@ -56,7 +56,7 @@ def test_add_record_posts_data_as_list(self, requests_mock, mocker, debugs_table
             "https://api.quickbase.com/v1/records", json={"blah": "bleh"}
         )
         client = QuickbaseTableClient(debugs_table, user_token="doesnotmatter")
-        spy = mocker.spy(client.api.rf.session, "request")
+        spy = mocker.spy(client.api._rf.session, "request")
         record = debugs_table(some_basic_text_field="hi", some_checkbox=False)
         client.add_record(record)
         args, kwargs = spy.call_args
@@ -69,7 +69,7 @@ def test_serializes_dates(self, requests_mock, mocker, debugs_table):
             "https://api.quickbase.com/v1/records", json={"blah": "bleh"}
         )
         client = QuickbaseTableClient(debugs_table, user_token="doesnotmatter")
-        spy = mocker.spy(client.api.rf.session, "request")
+        spy = mocker.spy(client.api._rf.session, "request")
         record = debugs_table(
             some_basic_text_field="hi", just_a_date=date(year=2020, month=2, day=7)
         )
@@ -80,7 +80,7 @@ def test_serializes_dates(self, requests_mock, mocker, debugs_table):
 
     def test_add_record_does_not_post_null_values(self, mocker, debugs_table):
         client = QuickbaseTableClient(debugs_table, user_token="doesnotmatter")
-        spy = mocker.spy(client.api.rf.session, "request")
+        spy = mocker.spy(client.api._rf.session, "request")
         record = debugs_table(some_basic_text_field="hi", some_checkbox=False)
         client.add_record(record)
         args, kwargs = spy.call_args
@@ -107,3 +107,11 @@ def test_query_with_pager(self, debugs_table, qb_api_mock):
         client.query(pager=pager)
         assert pager.total_records == 4
         assert not pager.more_remaining()
+
+    def test_wrapped_request_factory_forwards_allow_deletes(
+        self, debugs_table, qb_api_mock
+    ):
+        client = QuickbaseTableClient(debugs_table, user_token="doesnotmatter")
+        assert not client.api._rf.allow_deletes
+        client = QuickbaseTableClient(debugs_table, user_token="a", allow_deletes=True)
+        assert client.api._rf.allow_deletes

tests/test_orm/test_table.py

@@ -60,3 +60,7 @@ def test_get_report(self, example_table):
     def test_make_client(self, example_table):
         c = example_table.client("foo")
         assert isinstance(c, QuickbaseTableClient)
+
+    def test_make_client_forwards_kwargs(self, example_table):
+        c = example_table.client("foo", agent="foo")
+        assert c.api._rf.agent == "foo"

tests/test_tools/test_log_handler.py

@@ -49,15 +49,15 @@ def test_requires_correct_properties_if_default_record_factory(self):
     def test_posts_log_record(self, mocker):
         client = _MyLogsTable.client("foo")
         handler = QuickbaseLogHandler(client)
-        spy = mocker.spy(client.api.rf.session, "request")
+        spy = mocker.spy(client.api._rf.session, "request")
         handler._do_emit(MOCK_LOG)
         _, k = spy.call_args
         fid = str(_MyLogsTable.schema.level.fid)
         assert k["json"]["data"][0][fid]["value"] == MOCK_LOG_LEVEL
 
     def test_create_with_record_factory(self, mocker):
         client = _MyLogsTable.client("foo")
-        spy = mocker.spy(client.api.rf.session, "request")
+        spy = mocker.spy(client.api._rf.session, "request")
 
         def _mock_rf(record):
             return _MyLogsTable(message=record.msg)