Add string types (#14)

* Add string verbs to generate JSON object keys.

- Drop read_all as we shouldn't try to save `init=False` keys in attrs.
- Make sure helpers._Context is stringifying context items.

* Don't stringify bool as keys; that should be a custom rule.

Author: bsamuel-ui

json_syntax/__init__.py

@@ -22,6 +22,7 @@
 )
 from .attrs import attrs_classes, named_tuples, tuples
 from .unions import unions
+from .string import stringify_keys
 from .helpers import JSON2PY, PY2JSON, INSP_PY, INSP_JSON, PATTERN  # noqa
 
 
@@ -55,6 +56,7 @@ def std_ruleset(
         named_tuples,
         tuples,
         dicts,
+        stringify_keys,
         unions,
         *extras,
         cache=cache,

json_syntax/attrs.py

@@ -47,7 +47,7 @@ def attrs_classes(
     """
     if verb not in _SUPPORTED_VERBS:
         return
-    inner_map = build_attribute_map(verb, typ, ctx, read_all=verb == PY2JSON)
+    inner_map = build_attribute_map(verb, typ, ctx)
     if inner_map is None:
         return
 

json_syntax/extras/dynamodb.py

@@ -25,8 +25,16 @@
 Ref: https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_AttributeValue.html#DDB-Type-AttributeValue-NS
 """
 
-from json_syntax.helpers import issub_safe, NoneType, has_origin, get_origin
+from json_syntax.helpers import (
+    issub_safe,
+    NoneType,
+    has_origin,
+    get_origin,
+    STR2PY,
+    PY2STR,
+)
 from json_syntax.product import build_attribute_map
+from json_syntax.string import stringify_keys
 from json_syntax.ruleset import SimpleRuleSet
 
 import base64 as b64
@@ -39,6 +47,7 @@
 
 DDB2PY = "dynamodb_to_python"
 PY2DDB = "python_to_dynamodb"
+_STRING_ACTIONS = {DDB2PY: STR2PY, PY2DDB: PY2STR}
 
 
 def booleans(verb, typ, ctx):
@@ -122,17 +131,17 @@ def dicts(verb, typ, ctx):
     """
     A rule to represent lists as Dynamo list values.
     """
-    if not has_origin(typ, dict, num_args=2):
+    if verb not in _STRING_ACTIONS or not has_origin(typ, dict, num_args=2):
         return
     (key_typ, val_typ) = typ.__args__
-    if key_typ != str:
-        return
-
-    inner = ctx.lookup(verb=verb, typ=val_typ)
+    inner_key = ctx.lookup(verb=_STRING_ACTIONS[verb], typ=key_typ)
+    inner_val = ctx.lookup(verb=verb, typ=val_typ)
     if verb == DDB2PY:
-        return partial(decode_dict, inner_key=str, inner_val=inner, con=get_origin(typ))
+        return partial(
+            decode_dict, inner_key=inner_key, inner_val=inner_val, con=get_origin(typ)
+        )
     elif verb == PY2DDB:
-        return partial(encode_dict, inner=inner)
+        return partial(encode_dict, inner_key=inner_key, inner_val=inner_val)
 
 
 def sets(verb, typ, ctx):
@@ -169,7 +178,7 @@ def attrs(verb, typ, ctx):
     """
     A rule to represent attrs classes. This isn't trying to support hooks or any of that.
     """
-    inner_map = build_attribute_map(verb, typ, ctx, read_all=verb == PY2DDB)
+    inner_map = build_attribute_map(verb, typ, ctx)
     if inner_map is None:
         return
 
@@ -322,6 +331,7 @@ def dynamodb_ruleset(
         enums,
         sets,
         dicts,
+        stringify_keys,
         optionals,
         nulls,
         *extras,
@@ -461,8 +471,8 @@ def decode_dict(value, inner_key, inner_val, con):
     return con(((inner_key(key), inner_val(val)) for key, val in value.items()))
 
 
-def encode_dict(value, inner):
-    return {"M": {str(key): inner(val) for key, val in value.items()}}
+def encode_dict(value, inner_key, inner_val):
+    return {"M": {inner_key(key): inner_val(val) for key, val in value.items()}}
 
 
 def decode_map(value, inner_map, con):

json_syntax/helpers.py

@@ -9,6 +9,9 @@
 PY2JSON = "python_to_json"
 INSP_JSON = "inspect_json"
 INSP_PY = "inspect_python"
+INSP_STR = "inspect_string"
+STR2PY = "string_to_python"
+PY2STR = "python_to_string"
 PATTERN = "show_pattern"
 NoneType = type(None)
 SENTINEL = object()
@@ -173,7 +176,7 @@ def __init__(self, original, lead, context):
 
     def __str__(self):
         return "{}{}{}".format(
-            self.original, self.lead, "".join(reversed(self.context))
+            self.original, self.lead, "".join(map(str, reversed(self.context)))
         )
 
     def __repr__(self):

json_syntax/product.py

@@ -101,7 +101,7 @@ def attr_map(verb, outer, ctx, gen):
     return tuple(result)
 
 
-def build_attribute_map(verb, typ, ctx, read_all):
+def build_attribute_map(verb, typ, ctx):
     """
     Examine an attrs or dataclass type and construct a list of attributes.
 
@@ -129,7 +129,7 @@ def build_attribute_map(verb, typ, ctx, read_all):
                 default=field.default,
             )
             for field in fields
-            if read_all or field.init
+            if field.init
         ),
     )
 

json_syntax/std.py

@@ -8,6 +8,9 @@
     INSP_JSON,
     INSP_PY,
     PATTERN,
+    STR2PY,
+    PY2STR,
+    INSP_STR,
 )
 from .action_v1 import (
     check_collection,
@@ -288,45 +291,29 @@ def sets(verb, typ, ctx):
         return pat.Array.homog(inner)
 
 
-def _stringly(verb, typ, ctx):
-    """
-    Rule to handle types that reliably convert directly to strings.
-
-    This is used internally by dicts.
-    """
-    for base in str, int:
-        if typ == base:
-            if verb == PATTERN and base == str:
-                return pat.String.any
-            if verb in (JSON2PY, PY2JSON):
-                return base
-            elif verb == INSP_PY:
-                return partial(check_isinst, typ=base)
-            elif verb in (INSP_JSON, PATTERN):
-                inspect = partial(check_parse_error, parser=base, error=ValueError)
-                return pat.String(typ.__name__, inspect) if verb == PATTERN else inspect
-    if typ in (datetime, time):
-        return
-    for rule in enums, iso_dates:
-        action = rule(verb=verb, typ=typ, ctx=ctx)
-        if action is not None:
-            return action
+_STRING = {
+    JSON2PY: STR2PY,
+    PY2JSON: PY2STR,
+    INSP_JSON: INSP_STR,
+    INSP_PY: INSP_PY,
+    PATTERN: PATTERN,
+}
 
 
 def dicts(verb, typ, ctx):
     """
     Handle a ``Dict[key, value]`` where key is a string, integer, date or enum type.
     """
-    if not has_origin(typ, (dict, OrderedDict), num_args=2):
+    if verb not in _STRING or not has_origin(typ, (dict, OrderedDict), num_args=2):
         return
     (key_type, val_type) = typ.__args__
-    key_type = _stringly(verb=verb, typ=key_type, ctx=ctx)
-    if key_type is None:
-        return
-    val_type = ctx.lookup(verb=verb, typ=val_type)
+    inner_key = ctx.lookup(verb=_STRING[verb], typ=key_type)
+    inner_val = ctx.lookup(verb=verb, typ=val_type)
     if verb in (JSON2PY, PY2JSON):
-        return partial(convert_mapping, key=key_type, val=val_type, con=get_origin(typ))
+        return partial(
+            convert_mapping, key=inner_key, val=inner_val, con=get_origin(typ)
+        )
     elif verb in (INSP_JSON, INSP_PY):
-        return partial(check_mapping, key=key_type, val=val_type, con=get_origin(typ))
+        return partial(check_mapping, key=inner_key, val=inner_val, con=get_origin(typ))
     elif verb == PATTERN:
-        return pat.Object.homog(key_type, val_type)
+        return pat.Object.homog(inner_key, inner_val)

json_syntax/string.py

@@ -0,0 +1,56 @@
+from .action_v1 import (
+    check_parse_error,
+    check_str_enum,
+    convert_date,
+    convert_enum_str,
+    convert_str_enum,
+)
+from .helpers import STR2PY, PY2STR, INSP_STR, issub_safe
+
+from datetime import date
+from enum import Enum
+from functools import partial
+
+
+"""
+As JSON requires string keys, unless dicts are only allowed to be Dict[str, T], we need to be able to encode
+values as strings.
+
+Recommendations:
+
+* The string verbs are not intended for direct use.
+* Use these verbs for any type that must be represented as a key in a JSON object.
+* The standard rules will only handle types that are reliable keys and have obvious string encodings.
+
+See std.dicts for an example.
+"""
+
+
+def stringify_keys(verb, typ, ctx):
+    if verb not in (STR2PY, PY2STR, INSP_STR):
+        return
+    if typ in (str, int):
+        if verb == STR2PY:
+            return typ
+        elif verb == PY2STR:
+            return str
+        elif verb == INSP_STR:
+            return partial(check_parse_error, parser=typ, error=ValueError)
+    elif typ == date:
+        if verb == PY2STR:
+            return typ.isoformat
+        elif verb in (STR2PY, INSP_STR):
+            parse = convert_date
+            if verb == STR2PY:
+                return parse
+            else:
+                return partial(
+                    check_parse_error, parser=parse, error=(TypeError, ValueError)
+                )
+    elif issub_safe(typ, Enum):
+        if verb == PY2STR:
+            return partial(convert_enum_str, typ=typ)
+        elif verb == STR2PY:
+            return partial(convert_str_enum, typ=typ)
+        elif verb == INSP_STR:
+            return partial(check_str_enum, typ=typ)

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "json-syntax"
-version = "2.0.2"
+version = "2.1.0"
 description = "Generates functions to convert Python classes to JSON dumpable objects."
 authors = ["Ben Samuel <bsamuel@unitedincome.com>"]
 license = "MIT"