feat(json): add support for custom json parsers

Author: dfseifert

docs/examples/full_settings.py

@@ -1,9 +1,13 @@
+import json
+
 from qlient import Settings, Client
 
 my_settings = Settings(
     introspect=True,  # default, enable backend schema introspection
     validate_fields=True,  # default, enable query field selection validation
-    validate_variables=True  # default, enable query variable validation
+    validate_variables=True,  # default, enable query variable validation,
+    json_dumps=json.dumps,  # default, use python's builtin json.dumps for internal dumping
+    json_loads=json.loads,  # default, use python's builtin json.loads for internal loading
 )
 
 my_client = Client("https://...", settings=my_settings)

docs/examples/using_sqlite_cache.py

@@ -1,14 +1,20 @@
-from qlient import Client
+from qlient import Client, Settings
 from qlient.cache import SqliteCache
 
 client = Client("https://...", cache=SqliteCache())
 
 # or with custom settings
 
+settings = Settings(
+    json_loads=...,  # uses json.loads by default, can be overwritten to ujson.loads
+    json_dumps=...,  # and ujson.dumps
+)
+
 client = Client(
     "https://...",
     cache=SqliteCache(
         path="/path/to/my/schema_cache.sqlite",
-        expires_in=86400  # seconds
+        expires_in=86400,  # seconds
+        settings=settings,
     )
 )

poetry.lock

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qlient"
-version = "0.2.0-beta"
+version = "0.2.1-beta"
 description = "A fast and modern graphql client designed with simplicity in mind."
 authors = ["Daniel Seifert <[email protected]>"]
 maintainers = ["Daniel Seifert <[email protected]>"]

pyproject.toml

@@ -7,7 +7,6 @@
 import collections.abc
 import datetime
 import errno
-import json
 import logging
 import os
 import sqlite3
@@ -18,6 +17,7 @@
 
 import platformdirs
 
+from qlient.settings import Settings
 from qlient.schema.types import RawSchema
 
 logger = logging.getLogger("qlient")
@@ -120,30 +120,11 @@ class SqliteCache(Cache):
     LENGTH_STMT = f"SELECT COUNT(URL) AS CACHE_SIZE FROM {TABLE_NAME}"  # skipcq: BAN-B608
     ITER_STMT = f"SELECT URL, SCHEMA FROM {TABLE_NAME}"  # skipcq: BAN-B608
 
-    @staticmethod
-    def _encode_schema(schema: RawSchema) -> str:
-        """Static method to encode the raw schema before inserting it into the database
-
-        :param schema: holds the raw schema
-        :return: a base64 encoded representation of the schema
-        """
-        schema_string = json.dumps(schema, ensure_ascii=False)
-        return base64.b64encode(schema_string.encode()).decode()
-
-    @staticmethod
-    def _decode_schema(encoded_schema: str) -> RawSchema:
-        """Static method to decode the base64 encoded schema back to the dictionary
-
-        :param encoded_schema: holds a base64 representation of the schema
-        :return: a raw schema instance
-        """
-        decoded_raw_schema = base64.b64decode(encoded_schema.encode()).decode()
-        return json.loads(decoded_raw_schema)
-
     def __init__(
             self,
             path: Optional[str] = None,
-            expires_in: Union[int, datetime.timedelta] = ONE_HOUR
+            expires_in: Union[int, datetime.timedelta] = ONE_HOUR,
+            settings: Optional[Settings] = None,
     ):
         """Initialize a new sqlite cache
 
@@ -156,6 +137,7 @@ def __init__(
                 + "Please use qlient.cache.InMemoryCache()."
             )
 
+        self.settings: Settings = settings if settings is not None else Settings()
         self.path: str = path or _get_default_sqlite_cache_file()
 
         if isinstance(expires_in, int):
@@ -186,6 +168,24 @@ def create_cache_table_if_not_exists(self):
             cursor.execute(self.TABLE_STMT)
             connection.commit()
 
+    def _encode_schema(self, schema: RawSchema) -> str:
+        """Static method to encode the raw schema before inserting it into the database
+
+        :param schema: holds the raw schema
+        :return: a base64 encoded representation of the schema
+        """
+        schema_string = self.settings.json_dumps(schema, ensure_ascii=False)
+        return base64.b64encode(schema_string.encode()).decode()
+
+    def _decode_schema(self, encoded_schema: str) -> RawSchema:
+        """Static method to decode the base64 encoded schema back to the dictionary
+
+        :param encoded_schema: holds a base64 representation of the schema
+        :return: a raw schema instance
+        """
+        decoded_raw_schema = base64.b64decode(encoded_schema.encode()).decode()
+        return self.settings.json_loads(decoded_raw_schema)
+
     def __setitem__(self, url: str, schema: RawSchema):
         logger.debug(f"Sqlite caching schema for url `{url}`")
         encoded_schema = self._encode_schema(schema)

src/qlient/cache.py

@@ -3,6 +3,7 @@
 :author: Daniel Seifert
 :created: 09.09.2021
 """
+import json
 
 
 class Settings:
@@ -12,11 +13,15 @@ def __init__(
             self,
             introspect: bool = True,
             validate_variables: bool = True,
-            validate_fields: bool = True
+            validate_fields: bool = True,
+            json_loads=json.loads,
+            json_dumps=json.dumps,
     ):
         self.introspect: bool = introspect
         self.validate_variables: bool = validate_variables
         self.validate_fields: bool = validate_fields
+        self.json_loads = json_loads
+        self.json_dumps = json_dumps
 
     def __str__(self) -> str:
         """Return a simple string representation of the settings"""