init commit

Author: robswc

.gitignore

@@ -7,6 +7,7 @@ __pycache__/
 *.so
 
 # Distribution / packaging
+.keys
 .Python
 build/
 develop-eggs/

quickbase_json/__init__.py

@@ -0,0 +1,95 @@
+class IncorrectParameters(Exception):
+    def __init__(self, value, expected):
+        self.value = value
+        self.message = f'{value} is type {type(value)}.  Expected {expected}.'
+        super().__init__(self.message)
+
+
+def build_query_str(fid, operator, value):
+    return f'{{{fid}.{operator}.{value}}}'
+
+
+class QuickbaseParameter:
+
+    def build(self):
+        return 'Default String'
+
+    def __str__(self):
+        return self.build()
+
+
+class Where(QuickbaseParameter):
+    def __init__(self, fid: any, operator: str, value: any, **kwargs):
+        """
+        Initializes the quickbase query.
+        :param fid: Field Id, represents "where"
+        :param operator: Quickbase Query Language operator. https://help.quickbase.com/api-guide/do_query.html#queryOperators
+        :param value: Value to compare against
+        :param kwargs:
+        """
+        self.fid = fid
+        self.operator = operator
+        self.value = value
+
+        # add quotes for strings
+        if isinstance(self.value, str):
+            self.value = '"{}"'.format(self.value)
+
+    def build(self, **kwargs):
+
+        if kwargs.get('join') == 'OR':
+            # check that value is a list
+            if isinstance(self.value, list) is False:
+                raise IncorrectParameters(self.value, list)
+
+            # build queries
+            queries = []
+            for v in self.value:
+                queries.append(build_query_str(self.fid, self.operator, v))
+
+            # return chain of queries
+            return 'OR'.join(queries)
+
+        return build_query_str(self.fid, self.operator, self.value)
+
+
+class Sort(QuickbaseParameter):
+    def __init__(self, sort_pairs: list):
+        """
+        Creates a sort parameter for quickbase query.
+        :param sort_pairs: tuples of fid and order, i.e. (4, 'ASC')
+        """
+        self.sort_pairs = sort_pairs
+
+    def build(self):
+
+        # ensure pairs is a list
+        if not isinstance(self.sort_pairs, list):
+            raise IncorrectParameters(self.sort_pairs, list)
+
+        sorters = []
+        for pair in self.sort_pairs:
+            sorters.append({'fieldId': pair[0], 'order': pair[1]})
+
+        return sorters
+
+
+class Group(QuickbaseParameter):
+    def __init__(self, group_pairs: list):
+        """
+        Creates a groupBy parameter for quickbase query.
+        :param group_pairs: list of tuples, i.e. (3, 'equal-value')
+        """
+        self.group_pairs = group_pairs
+
+    def build(self):
+
+        # ensure pairs is a list
+        if not isinstance(self.group_pairs, list):
+            raise IncorrectParameters(self.group_pairs, list)
+
+        sorters = []
+        for pair in self.group_pairs:
+            sorters.append({'fieldId': pair[0], 'grouping': pair[1]})
+
+        return sorters

qb_json_client.py quickbase_json/client.py

@@ -0,0 +1,3 @@
+setuptools~=45.2.0
+requests~=2.24.0
+requests~=2.24.0

quickbase_json/helpers.py

@@ -0,0 +1,13 @@
+from setuptools import find_packages, setup
+setup(
+    name='quickbase-json',
+    packages=find_packages(include=['quickbase_json']),
+    version='0.1.0',
+    description='Quickbase JSON API wrapper for python',
+    author='Robert Carroll',
+    license='MIT',
+    install_requires=['requests=>2.24.0'],
+    setup_requires=['pytest-runner'],
+    tests_require=['pytest==4.4.1'],
+    test_suite='tests',
+)

requirements.txt

@@ -0,0 +1,33 @@
+import datetime
+
+import pytest
+
+from quickbase_json import client as qbc
+from quickbase_json.helpers import Where, IncorrectParameters
+from quickbase_json.helpers import Sort as qbs
+from quickbase_json.helpers import Group as qbg
+
+
+# test where
+@pytest.mark.parametrize('fid, operator, value, expected', [
+    (3, 'EX', 12345, '{3.EX.12345}'),
+    (3, 'XEX', 12345, '{3.XEX.12345}'),
+    (10, 'EX', 12345, '{10.EX.12345}')
+])
+def test_where(fid, operator, value, expected):
+    assert Where(fid, operator, value).build() == expected
+
+
+@pytest.mark.parametrize('fid, operator, value, expected', [
+    (3, 'EX', [1, 2, 3, 4, 5], '{3.EX.1}OR{3.EX.2}OR{3.EX.3}OR{3.EX.4}OR{3.EX.5}'),
+    (3, 'EX', [1], '{3.EX.1}')
+])
+def test_where_join(fid, operator, value, expected):
+    assert Where(fid, operator, value).build(join='OR') == expected
+
+
+# test invalid parameters, given to where
+def test_invalid_params():
+    with pytest.raises(IncorrectParameters):
+        Where(3, 'EX', 12345).build(join='OR')
+