edq-utils 0.2.3__py3-none-any.whl

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

@@ -0,0 +1,5 @@
+{
+    "method": "GET",
+    "url": "simple#a",
+    "response_body": "simple_anchor"
+}

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

@@ -0,0 +1,10 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "files": [
+        {
+            "path": "../files/a.txt"
+        }
+    ],
+    "response_body": "simple_file"
+}

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

@@ -0,0 +1,10 @@
+{
+    "method": "GET",
+    "url": "simple",
+    "files": [
+        {
+            "path": "../files/tiny.png"
+        }
+    ],
+    "response_body": "simple_file_binary"
+}

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

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

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

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

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

@@ -0,0 +1,88 @@
+import typing
+import unittest
+
+import edq.util.json
+import edq.util.reflection
+
+FORMAT_STR: str = "\n--- Expected ---\n%s\n--- Actual ---\n%s\n---\n"
+
+class BaseTest(unittest.TestCase):
+    """
+    A base class for unit tests.
+    """
+
+    maxDiff = None
+    """ Don't limit the size of diffs. """
+
+    def assertJSONEqual(self, a: typing.Any, b: typing.Any, message: typing.Union[str, None] = None) -> None:  # pylint: disable=invalid-name
+        """
+        Like unittest.TestCase.assertEqual(),
+        but uses a default assertion 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)
+
+        if (message is None):
+            message = FORMAT_STR % (a_json, b_json)
+
+        super().assertEqual(a, b, msg = message)
+
+    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 a default assertion message containing the full JSON representation of the arguments.
+        """
+
+        if (not isinstance(a, dict)):
+            if (isinstance(a, edq.util.json.DictConverter)):
+                a = a.to_dict()
+            else:
+                a = vars(a)
+
+        if (not isinstance(b, dict)):
+            if (isinstance(b, edq.util.json.DictConverter)):
+                b = b.to_dict()
+            else:
+                b = vars(b)
+
+        a_json = edq.util.json.dumps(a, indent = 4)
+        b_json = edq.util.json.dumps(b, indent = 4)
+
+        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], message: typing.Union[str, None] = None) -> None:  # pylint: disable=invalid-name
+        """
+        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)
+
+        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:
+        """
+        Format an error string from an exception so it can be checked for testing.
+        The type of the error will be included,
+        and any nested errors will be joined together.
+        """
+
+        parts = []
+
+        while (ex is not None):
+            type_name = edq.util.reflection.get_qualified_name(ex)
+            message = str(ex)
+
+            parts.append(f"{type_name}: {message}")
+
+            ex = ex.__cause__
+
+        return "; ".join(parts)

edq/util/__init__.py

@@ -0,0 +1,3 @@
+"""
+Low-level utilities.
+"""

edq/util/cli.py

@@ -0,0 +1,151 @@
+"""
+Show the CLI tools available in this package.
+
+This will look for objects that "look like" CLI tools.
+A package looks like a CLI package if it has a __main__.py file.
+A module looks like a CLI tool if it has the following functions:
+ - `def _get_parser() -> argparse.ArgumentParser:`
+ - `def run_cli(args: argparse.Namespace) -> int:`
+"""
+
+import argparse
+import inspect
+import os
+
+import edq.util.dirent
+import edq.util.pyimport
+
+def auto_list(
+        recursive: bool = False,
+        skip_dirs: bool = False,
+        ) -> None:
+    """
+    Print the caller's docstring and call _list_dir() on it,
+    but will figure out the package's docstring, base_dir, and command_prefix automatically.
+    This will use the inspect library, so only use in places that use code normally.
+    The first stack frame not in this file will be used.
+    """
+
+    this_path = os.path.realpath(__file__)
+
+    caller_frame_info = None
+    for frame_info in inspect.stack():
+        if (edq.util.dirent.same(this_path, frame_info.filename)):
+            # Ignore this file.
+            continue
+
+        caller_frame_info = frame_info
+        break
+
+    if (caller_frame_info is None):
+        raise ValueError("Unable to determine caller's stack frame.")
+
+    path = caller_frame_info.filename
+    base_dir = os.path.dirname(path)
+
+    try:
+        module = inspect.getmodule(caller_frame_info.frame)
+        if (module is None):
+            raise ValueError(f"Unable to get module for '{path}'.")
+    except Exception as ex:
+        raise ValueError("Unable to get caller information for listing CLI information.") from ex
+
+    if (module.__package__ is None):
+        raise ValueError(f"Caller module has no package information: '{path}'.")
+
+    if (module.__doc__ is None):
+        raise ValueError(f"Caller module has no docstring: '{path}'.")
+
+    print(module.__doc__.strip())
+    _list_dir(base_dir, module.__package__, recursive, skip_dirs)
+
+def _list_dir(base_dir: str, command_prefix: str, recursive: bool, skip_dirs: bool) -> None:
+    """ List/descend the given dir. """
+
+    for dirent in sorted(os.listdir(base_dir)):
+        path = os.path.join(base_dir, dirent)
+        cmd = command_prefix + '.' + os.path.splitext(dirent)[0]
+
+        if (dirent.startswith('__')):
+            continue
+
+        if (os.path.isfile(path)):
+            _handle_file(path, cmd)
+        else:
+            if (not skip_dirs):
+                _handle_dir(path, cmd)
+
+            if (recursive):
+                _list_dir(path, cmd, recursive, skip_dirs)
+
+def _handle_file(path: str, cmd: str) -> None:
+    """ Process a file (possible module). """
+
+    if (not path.endswith('.py')):
+        return
+
+    try:
+        module = edq.util.pyimport.import_path(path)
+    except Exception:
+        print("ERROR Importing: ", path)
+        return
+
+    if ('_get_parser' not in dir(module)):
+        return
+
+    parser = module._get_parser()
+    parser.prog = 'python3 -m ' + cmd
+
+    print()
+    print(cmd)
+    print(parser.description)
+    parser.print_usage()
+
+def _handle_dir(path: str, cmd: str) -> None:
+    """ Process a dir (possible package). """
+
+    try:
+        module = edq.util.pyimport.import_path(os.path.join(path, '__main__.py'))
+    except Exception:
+        return
+
+    description = module.__doc__.strip()
+
+    print()
+    print(cmd + '.*')
+    print(description)
+    print(f"See `python3 -m {cmd}` for more information.")
+
+def _get_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description = __doc__.strip(),
+        epilog = ("Note that you don't need to provide a package as an argument,"
+            + " since you already called this on the target package."))
+
+    parser.add_argument('-r', '--recursive', dest = 'recursive',
+        action = 'store_true', default = False,
+        help = 'Recur into each package to look for tools and subpackages (default: %(default)s).')
+
+    parser.add_argument('-s', '--skip-dirs', dest = 'skip_dirs',
+        action = 'store_true', default = False,
+        help = ('Do not output information about directories/packages,'
+            + ' only tools/files/modules (default: %(default)s).'))
+
+    return parser
+
+def run_cli(args: argparse.Namespace) -> int:
+    """
+    List the caller's dir.
+    """
+
+    auto_list(recursive = args.recursive, skip_dirs = args.skip_dirs)
+
+    return 0
+
+def main() -> int:
+    """
+    Run as if this process has been called as a executable.
+    This will parse the command line and list the caller's dir.
+    """
+
+    return run_cli(_get_parser().parse_args())