edq-utils 0.0.5__py3-none-any.whl → 0.0.6__py3-none-any.whl

edq/testing/testdata/http/exchanges/simple_file_name.httpex.json

@@ -0,0 +1,11 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "files": [
+        {
+            "path": "../files/a.txt",
+            "name": "foo.txt"
+        }
+    ],
+    "response_body": "simple_file_name"
+}

edq/testing/testdata/http/exchanges/simple_file_post_multiple.httpex.json

@@ -0,0 +1,13 @@
+{
+    "method": "POST",
+    "url": "simple",
+    "files": [
+        {
+            "path": "../files/a.txt"
+        },
+        {
+            "path": "../files/tiny.png"
+        }
+    ],
+    "response_body": "simple_file_post_multiple"
+}

edq/testing/testdata/http/exchanges/simple_file_post_params.httpex.json

@@ -0,0 +1,14 @@
+{
+    "method": "POST",
+    "url": "simple",
+    "parameters": {
+        "a": "1",
+        "b": "2"
+    },
+    "files": [
+        {
+            "path": "../files/a.txt"
+        }
+    ],
+    "response_body": "simple_file_post_params"
+}

edq/testing/testdata/http/exchanges/simple_headers.httpex.json

@@ -0,0 +1,8 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "headers": {
+        "a": "1"
+    },
+    "response_body": "simple_headers"
+}

edq/testing/testdata/http/exchanges/simple_jsonresponse_dict.httpex.json

@@ -0,0 +1,7 @@
+{
+    "method": "GET",
+    "url": "simple/jsonresponse/dict",
+    "response_body": {
+        "a": 1
+    }
+}

edq/testing/testdata/http/exchanges/simple_jsonresponse_list.httpex.json

@@ -0,0 +1,9 @@
+{
+    "method": "GET",
+    "url": "simple/jsonresponse/list",
+    "response_body": [
+        {
+            "a": 1
+        }
+    ]
+}

edq/testing/testdata/http/exchanges/simple_params.httpex.json

@@ -0,0 +1,9 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "parameters": {
+        "a": "1",
+        "b": "2"
+    },
+    "response_body": "simple_params"
+}

edq/testing/testdata/http/exchanges/simple_post.httpex.json

@@ -0,0 +1,5 @@
+{
+    "method": "POST",
+    "url": "simple",
+    "response_body": "simple_post"
+}

edq/testing/testdata/http/exchanges/simple_post_params.httpex.json

@@ -0,0 +1,9 @@
+{
+    "method": "POST",
+    "url": "simple",
+    "parameters": {
+        "a": "1",
+        "b": "2"
+    },
+    "response_body": "simple_post_params"
+}

edq/testing/testdata/http/exchanges/simple_post_urlparams.httpex.json

@@ -0,0 +1,5 @@
+{
+    "method": "POST",
+    "url": "simple?c=3&d=4",
+    "response_body": "simple_post_urlparams"
+}

edq/testing/testdata/http/exchanges/simple_urlparams.httpex.json

@@ -0,0 +1,5 @@
+{
+    "method": "GET",
+    "url": "simple?c=3&d=4",
+    "response_body": "simple_urlparams"
+}

edq/testing/testdata/http/exchanges/specialcase_listparams_explicit.httpex.json

@@ -0,0 +1,8 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "parameters": {
+        "a": ["1", "2"]
+    },
+    "response_body": "specialcase_listparams_explicit"
+}

edq/testing/testdata/http/exchanges/specialcase_listparams_url.httpex.json

@@ -0,0 +1,5 @@
+{
+    "method": "GET",
+    "url": "simple?b=1&b=2",
+    "response_body": "specialcase_listparams_url"
+}

edq/testing/testdata/http/files/a.txt

@@ -0,0 +1 @@
+a

edq/testing/unittest.py

@@ -14,12 +14,11 @@ class BaseTest(unittest.TestCase):
     maxDiff = None
     """ Don't limit the size of diffs. """
 
-    def assertJSONDictEqual(self, a: typing.Any, b: typing.Any) -> None:  # pylint: disable=invalid-name
+    def assertJSONDictEqual(self, a: typing.Any, b: typing.Any, message: typing.Union[str, None] = None) -> None:  # pylint: disable=invalid-name
         """
         Like unittest.TestCase.assertDictEqual(),
         but will try to convert each comparison argument to a dict if it is not already,
-        and uses an assertion message containing the full JSON representation of the arguments.
-
+        and uses a default assertion message containing the full JSON representation of the arguments.
         """
 
         if (not isinstance(a, dict)):
@@ -37,17 +36,23 @@ class BaseTest(unittest.TestCase):
         a_json = edq.util.json.dumps(a, indent = 4)
         b_json = edq.util.json.dumps(b, indent = 4)
 
-        super().assertDictEqual(a, b, FORMAT_STR % (a_json, b_json))
+        if (message is None):
+            message = FORMAT_STR % (a_json, b_json)
+
+        super().assertDictEqual(a, b, msg = message)
 
-    def assertJSONListEqual(self, a: typing.List[typing.Any], b: typing.List[typing.Any]) -> None:  # pylint: disable=invalid-name
+    def assertJSONListEqual(self, a: typing.List[typing.Any], b: typing.List[typing.Any], message: typing.Union[str, None] = None) -> None:  # pylint: disable=invalid-name
         """
-        Call assertListEqual(), but supply a message containing the full JSON representation of the arguments.
+        Call assertDictEqual(), but supply a default message containing the full JSON representation of the arguments.
         """
 
         a_json = edq.util.json.dumps(a, indent = 4)
         b_json = edq.util.json.dumps(b, indent = 4)
 
-        super().assertListEqual(a, b, FORMAT_STR % (a_json, b_json))
+        if (message is None):
+            message = FORMAT_STR % (a_json, b_json)
+
+        super().assertListEqual(a, b, msg = message)
 
     def format_error_string(self, ex: typing.Union[BaseException, None]) -> str:
         """

edq/util/dirent.py

@@ -41,6 +41,8 @@ def get_temp_path(prefix: str = '', suffix: str = '', rm: bool = True) -> str:
     while ((path is None) or exists(path)):
         path = os.path.join(tempfile.gettempdir(), prefix + str(uuid.uuid4()) + suffix)
 
+    path = os.path.realpath(path)
+
     if (rm):
         atexit.register(remove, path)
 

edq/util/json.py

@@ -4,37 +4,45 @@ Specifically, we try to be flexible when reading (using JSON5),
 and strict when writing (using vanilla JSON).
 """
 
-import abc
 import enum
 import json
+import os
 import typing
 
 import json5
 
 import edq.util.dirent
 
-class DictConverter(abc.ABC):
+class DictConverter():
     """
     A base class for class that can represent (serialize) and reconstruct (deserialize) themselves as/from a dict.
     The intention is that the dict can then be cleanly converted to/from JSON.
+
+    General (but inefficient) implementations of several core Python equality, comparison, and representation methods are provided.
     """
 
-    @abc.abstractmethod
     def to_dict(self) -> typing.Dict[str, typing.Any]:
         """
         Return a dict that can be used to represent this object.
         If the dict is passed to from_dict(), an identical object should be reconstructed.
+
+        A general (but inefficient) implementation is provided by default.
         """
 
+        return vars(self).copy()
+
     @classmethod
-    @abc.abstractmethod
     # Note that `typing.Self` is returned, but that is introduced in Python 3.12.
     def from_dict(cls, data: typing.Dict[str, typing.Any]) -> typing.Any:
         """
         Return an instance of this subclass created using the given dict.
         If the dict came from to_dict(), the returned object should be identical to the original.
+
+        A general (but inefficient) implementation is provided by default.
         """
 
+        return cls(**data)
+
     def __eq__(self, other: object) -> bool:
         """
         Check for equality.
@@ -49,6 +57,12 @@ class DictConverter(abc.ABC):
 
         return bool(self.to_dict() == other.to_dict())  # type: ignore[attr-defined]
 
+    def __lt__(self, other: 'DictConverter') -> bool:
+        return dumps(self) < dumps(other)
+
+    def __hash__(self) -> int:
+        return hash(dumps(self))
+
     def __str__(self) -> str:
         return dumps(self)
 
@@ -107,6 +121,9 @@ def load_path(
     otherwise use JSON5.
     """
 
+    if (os.path.isdir(path)):
+        raise IsADirectoryError(f"Cannot open JSON file, expected a file but got a directory at '{path}'.")
+
     try:
         with open(path, 'r', encoding = encoding) as file:
             return load(file, strict = strict, **kwargs)