Add in-memory caching around AST parsing.

Author: adamghill

django_unicorn/call_method_parser.py

@@ -1,5 +1,6 @@
 import ast
 import logging
+from functools import lru_cache
 from typing import Any, Dict, List, Tuple
 from uuid import UUID
 
@@ -13,7 +14,7 @@
 
 logger = logging.getLogger(__name__)
 
-# Lambdas that attempt to convert something that failed while being parsed by `ast.parse`.
+# Lambdas that attempt to convert something that failed while being parsed by `ast.literal_eval`.
 CASTERS = [
     lambda a: parse_datetime(a),
     lambda a: parse_time(a),
@@ -27,23 +28,6 @@ class InvalidKwarg(Exception):
     pass
 
 
-def eval_arg(arg):
-    try:
-        arg = ast.literal_eval(arg)
-    except SyntaxError:
-        for caster in CASTERS:
-            try:
-                casted_value = caster(arg)
-
-                if casted_value:
-                    arg = casted_value
-                    break
-            except ValueError:
-                pass
-
-    return arg
-
-
 def _get_expr_string(expr: ast.expr) -> str:
     """
     Builds a string based on traversing `ast.Attribute` and `ast.Name` expressions.
@@ -79,6 +63,32 @@ def _get_expr_string(expr: ast.expr) -> str:
     return expr_str
 
 
+@lru_cache(maxsize=128)
+def eval_value(value):
+    """
+    Uses `ast.literal_eval` to parse strings into an appropriate Python primative.
+
+    Also returns an appropriate object for strings that look like they represent datetime, 
+    date, time, duration, or UUID.
+    """
+
+    try:
+        value = ast.literal_eval(value)
+    except SyntaxError:
+        for caster in CASTERS:
+            try:
+                casted_value = caster(value)
+
+                if casted_value:
+                    value = casted_value
+                    break
+            except ValueError:
+                pass
+
+    return value
+
+
+@lru_cache(maxsize=128)
 def parse_kwarg(kwarg: str, raise_if_unparseable=False) -> Dict[str, Any]:
     """
     Parses a potential kwarg as a string into a dictionary.
@@ -104,21 +114,22 @@ def parse_kwarg(kwarg: str, raise_if_unparseable=False) -> Dict[str, Any]:
                 target = assign.targets[0]
                 key = _get_expr_string(target)
 
-                return {key: ast.literal_eval(assign.value)}
+                return {key: eval_value(assign.value)}
             except ValueError:
                 if raise_if_unparseable:
                     raise
 
                 # The value can be a template variable that will get set from the context when
-                # the templatetag is rendered
-                val = _get_expr_string(assign.value)
-                return {target.id: val}
+                # the templatetag is rendered, so just return the expr as a string.
+                value = _get_expr_string(assign.value)
+                return {target.id: value}
         else:
             raise InvalidKwarg(f"'{kwarg}' is invalid")
     except SyntaxError:
         raise InvalidKwarg(f"'{kwarg}' could not be parsed")
 
 
+@lru_cache(maxsize=128)
 def parse_call_method_name(call_method_name: str) -> Tuple[str, List[Any]]:
     """
     Parses the method name from the request payload into a set of parameters to pass to a method.
@@ -145,10 +156,10 @@ def parse_call_method_name(call_method_name: str) -> Tuple[str, List[Any]]:
     if tree.body and isinstance(tree.body[0].value, ast.Call):
         call = tree.body[0].value
         method_name = call.func.id
-        args = [eval_arg(arg) for arg in call.args]
+        args = [eval_value(arg) for arg in call.args]
 
         # Not returned, but might be usable
-        kwargs = {kw.arg: eval_arg(kw.value) for kw in call.keywords}
+        kwargs = {kw.arg: eval_value(kw.value) for kw in call.keywords}
 
     # Add "$" back to special functions
     if dollar_func:

tests/call_method_parser/test_parse_args.py

@@ -3,12 +3,12 @@
 
 import pytest
 
-from django_unicorn.call_method_parser import eval_arg
+from django_unicorn.call_method_parser import eval_value
 
 
 def test_args():
     expected = (1, 2)
-    actual = eval_arg("1, 2")
+    actual = eval_value("1, 2")
 
     assert actual == expected
     assert isinstance(actual[0], int)
@@ -17,79 +17,79 @@ def test_args():
 
 def test_single_quote_str_arg():
     expected = "1"
-    actual = eval_arg("'1'")
+    actual = eval_value("'1'")
 
     assert actual == expected
     assert isinstance(actual, str)
 
 
 def test_str_with_space_arg():
     expected = "django unicorn"
-    actual = eval_arg("'django unicorn'")
+    actual = eval_value("'django unicorn'")
 
     assert actual == expected
     assert isinstance(actual, str)
 
 
 def test_str_with_extra_single_quote():
     expected = "django's unicorn"
-    actual = eval_arg("'django\\'s unicorn'")
+    actual = eval_value("'django\\'s unicorn'")
 
     assert actual == expected
     assert isinstance(actual, str)
 
 
 def test_str_with_extra_double_quote():
     expected = 'django "unicorn"'
-    actual = eval_arg("'django \"unicorn\"'")
+    actual = eval_value("'django \"unicorn\"'")
 
     assert actual == expected
     assert isinstance(actual[0], str)
 
 
 def test_str_with_comma():
     expected = "'a', b'"
-    actual = eval_arg("'a', b'")
+    actual = eval_value("'a', b'")
 
     assert actual == expected
     assert isinstance(actual[0], str)
 
 
 def test_str_with_stop_character():
     expected = "'a'} b'"
-    actual = eval_arg("'a'} b'")
+    actual = eval_value("'a'} b'")
 
     assert actual == expected
     assert isinstance(actual[0], str)
 
 
 def test_double_quote_str_arg():
     expected = "string"
-    actual = eval_arg('"string"')
+    actual = eval_value('"string"')
 
     assert actual == expected
     assert isinstance(actual, str)
 
 
 def test_args_with_single_quote_dict():
     expected = (1, {"2": 3})
-    actual = eval_arg("1, {'2': 3}")
+    actual = eval_value("1, {'2': 3}")
 
     assert actual == expected
     assert isinstance(actual[1], dict)
 
 
 def test_args_with_double_quote_dict():
     expected = (1, {"2": 3})
-    actual = eval_arg('1, {"2": 3}')
+    actual = eval_value('1, {"2": 3}')
 
     assert actual == expected
     assert isinstance(actual[1], dict)
 
 
 def test_args_with_nested_dict():
     expected = (1, {"2": {"3": 4}})
-    actual = eval_arg("1, {'2': { '3': 4 }}")
+    actual = eval_value("1, {'2': { '3': 4 }}")
 
     assert actual == expected
     assert isinstance(actual[1], dict)
@@ -98,59 +98,59 @@ def test_args_with_nested_dict():
 
 def test_args_with_nested_list_3():
     expected = ([1, ["2", "3"], 4], 9)
-    actual = eval_arg("[1, ['2', '3'], 4], 9")
+    actual = eval_value("[1, ['2', '3'], 4], 9")
 
     assert actual == expected
 
 
 def test_args_with_nested_tuple():
     expected = (9, (1, ("2", "3"), 4))
-    actual = eval_arg("9, (1, ('2', '3'), 4)")
+    actual = eval_value("9, (1, ('2', '3'), 4)")
 
     assert actual == expected
 
 
 def test_args_with_nested_objects():
     expected = ([0, 1], {"2 2": {"3": 4}}, (5, 6, [7, 8]))
-    actual = eval_arg("[0,  1], {'2 2': { '3': 4 }}, (5, 6, [7, 8])")
+    actual = eval_value("[0,  1], {'2 2': { '3': 4 }}, (5, 6, [7, 8])")
 
     assert actual == expected
 
 
 def test_list_args():
     expected = (1, [2, "3"])
-    actual = eval_arg("1, [2, '3']")
+    actual = eval_value("1, [2, '3']")
 
     assert actual == expected
 
 
 def test_datetime():
     expected = datetime(2020, 9, 12, 1, 1, 1)
-    actual = eval_arg("2020-09-12T01:01:01")
+    actual = eval_value("2020-09-12T01:01:01")
 
     assert actual == expected
     assert isinstance(actual, datetime)
 
 
 def test_uuid():
     expected = UUID("90144cb9-fc47-476d-b124-d543b0cff091")
-    actual = eval_arg("90144cb9-fc47-476d-b124-d543b0cff091")
+    actual = eval_value("90144cb9-fc47-476d-b124-d543b0cff091")
 
     assert actual == expected
     assert isinstance(actual, UUID)
 
 
 def test_float():
     expected = [1, 5.4]
-    actual = eval_arg("[1, 5.4]")
+    actual = eval_value("[1, 5.4]")
 
     assert actual == expected
     assert isinstance(actual[1], float)
 
 
 def test_set():
     expected = {1, 5}
-    actual = eval_arg("{1, 5}")
+    actual = eval_value("{1, 5}")
 
     assert actual == expected
     assert isinstance(actual, set)