Allow untyped dicts in get_file_contents (#112)

* Fix docstring and allow untyped dicts in get_file_contents

Author: olliesilvester

src/daq_config_server/client.py

@@ -1,8 +1,7 @@
 import operator
-from collections import defaultdict
 from logging import Logger, getLogger
 from pathlib import Path
-from typing import Any, TypeVar
+from typing import Any, TypeVar, get_origin
 
 import requests
 from cachetools import TTLCache, cachedmethod
@@ -17,17 +16,16 @@
 T = TypeVar("T", str, bytes, dict[Any, Any])
 
 
-return_type_to_mime_type: dict[type, ValidAcceptHeaders] = defaultdict(
-    lambda: ValidAcceptHeaders.PLAIN_TEXT,
-    {
-        dict[Any, Any]: ValidAcceptHeaders.JSON,
-        str: ValidAcceptHeaders.PLAIN_TEXT,
-        bytes: ValidAcceptHeaders.RAW_BYTES,
-    },
-)
+class TypeConversionException(Exception): ...
 
 
-class TypeConversionException(Exception): ...
+def _get_mime_type(requested_return_type: type[T]) -> ValidAcceptHeaders:
+    # Get correct mapping for typed dict or plain dict
+    if get_origin(requested_return_type) is dict or requested_return_type is dict:
+        return ValidAcceptHeaders.JSON
+    elif requested_return_type is bytes:
+        return ValidAcceptHeaders.RAW_BYTES
+    return ValidAcceptHeaders.PLAIN_TEXT
 
 
 class ConfigServer:
@@ -143,22 +141,24 @@ def get_file_contents(
         Get contents of a file from the config server in the format specified.
         Optionally look for cached result before making request.
 
-        Current supported return types are: str, bytes, dict[str, str]. This option will
-        determine how the server attempts to decode the file
+        Current supported return types are: str, bytes, dict. This option will
+        determine how the server attempts to decode the file. Note that only untyped
+        dictionaries are currently supported
 
         Args:
             file_path: Path to the file.
-            requested_response_format: Specify how to parse the response.
-            desired_return_type: If true, make a request and store response in cache,
+            desired_return_type: Specify how to parse the response.
+            reset_cached_result: If true, make a request and store response in cache,
                                 otherwise look for cached response before making
                                 new request
         Returns:
             The file contents, in the format specified.
         """
         file_path = Path(file_path)
-        accept_header = return_type_to_mime_type[desired_return_type]
 
-        return TypeAdapter(desired_return_type).validate_python(  # type: ignore - to allow any dict
+        accept_header = _get_mime_type(desired_return_type)
+
+        return TypeAdapter(desired_return_type).validate_python(
             self._get(
                 ENDPOINTS.CONFIG,
                 accept_header,

tests/system_tests/test_client.py

@@ -63,6 +63,20 @@ def test_read_good_json_as_dict(server: ConfigServer):
     )
 
 
+@pytest.mark.requires_local_server
+def test_read_good_json_as_untyped_dict(server: ConfigServer):
+    with open(TestDataPaths.TEST_GOOD_JSON_PATH) as f:
+        expected_response = json.loads(f.read())
+
+    assert (
+        server.get_file_contents(
+            ServerFilePaths.GOOD_JSON_FILE,
+            dict,
+        )
+        == expected_response
+    )
+
+
 @pytest.mark.requires_local_server
 def test_bad_json_gives_http_error_with_details(server: ConfigServer):
     file_path = ServerFilePaths.BAD_JSON_FILE

tests/unit_tests/test_client.py

@@ -8,7 +8,12 @@
 from httpx import Response
 
 from daq_config_server.app import ValidAcceptHeaders
-from daq_config_server.client import ConfigServer, TypeConversionException
+from daq_config_server.client import (
+    ConfigServer,
+    T,
+    TypeConversionException,
+    _get_mime_type,
+)
 from daq_config_server.constants import ENDPOINTS
 from daq_config_server.testing import make_test_response
 
@@ -109,3 +114,31 @@ def test_bad_responses_with_details_raises_error(mock_request: MagicMock):
     with pytest.raises(requests.exceptions.HTTPError):
         server.get_file_contents(test_path)
     server._log.error.assert_called_once_with(detail)
+
+
+@patch("daq_config_server.client.requests.get")
+def test_get_file_contents_with_untyped_dict(mock_request: MagicMock):
+    content_type = ValidAcceptHeaders.JSON
+    good_json = '{"good_dict":"test"}'
+    mock_request.return_value = make_test_response(
+        good_json, content_type=content_type, json_value=good_json
+    )
+    url = "url"
+    server = ConfigServer(url)
+    assert server.get_file_contents(test_path, desired_return_type=dict) == {
+        "good_dict": "test"
+    }
+
+
+@pytest.mark.parametrize(
+    "input, expected",
+    [
+        (dict, ValidAcceptHeaders.JSON),
+        (dict[str, bytes], ValidAcceptHeaders.JSON),
+        (dict[Any, Any], ValidAcceptHeaders.JSON),
+        (str, ValidAcceptHeaders.PLAIN_TEXT),
+        (bytes, ValidAcceptHeaders.RAW_BYTES),
+    ],
+)
+def test_get_mime_type(input: type[T], expected: ValidAcceptHeaders):
+    assert _get_mime_type(input) == expected