Prepare for UpdateExpression API (#348)

Author: jpinner-lyft

pynamodb/attributes.py

@@ -14,7 +14,7 @@
     STRING, STRING_SHORT, NUMBER, BINARY, UTC, DATETIME_FORMAT, BINARY_SET, STRING_SET, NUMBER_SET,
     MAP, MAP_SHORT, LIST, LIST_SHORT, DEFAULT_ENCODING, BOOLEAN, ATTR_TYPE_MAP, NUMBER_SHORT, NULL, SHORT_ATTR_TYPES
 )
-from pynamodb.expressions.condition import Path
+from pynamodb.expressions.operand import AttributePath
 import collections
 
 
@@ -106,7 +106,7 @@ def __ge__(self, other):
         return AttributePath(self).__ge__(other)
 
     def __getitem__(self, idx):
-        return AttributePath(self)[idx]
+        return AttributePath(self).__getitem__(idx)
 
     def between(self, lower, upper):
         return AttributePath(self).between(lower, upper)
@@ -131,39 +131,6 @@ def contains(self, item):
         return AttributePath(self).contains(item)
 
 
-class AttributePath(Path):
-
-    def __init__(self, attribute):
-        super(AttributePath, self).__init__(attribute.attr_path)
-        self.attribute = attribute
-
-    def __getitem__(self, idx):
-        if self.attribute.attr_type != LIST:  # only list elements support the list dereference operator
-            raise TypeError("'{0}' object has no attribute __getitem__".format(self.attribute.__class__.__name__))
-        # The __getitem__ call returns a new Path instance, not an AttributePath instance.
-        # This is intended since the list element is not the same attribute as the list itself.
-        return super(AttributePath, self).__getitem__(idx)
-
-    def contains(self, item):
-        if self.attribute.attr_type in [BINARY_SET, NUMBER_SET, STRING_SET]:
-            # Set attributes assume the values to be serialized are sets.
-            (attr_type, attr_value), = self._serialize([item]).items()
-            item = {attr_type[0]: attr_value[0]}
-        return super(AttributePath, self).contains(item)
-
-    def _serialize(self, value):
-        # Check to see if value is already serialized
-        if isinstance(value, dict) and len(value) == 1 and list(value.keys())[0] in SHORT_ATTR_TYPES:
-            return value
-        if self.attribute.attr_type == LIST and not isinstance(value, list):
-            # List attributes assume the values to be serialized are lists.
-            return self.attribute.serialize([value])[0]
-        if self.attribute.attr_type == MAP and not isinstance(value, dict):
-            # Map attributes assume the values to be serialized are maps.
-            return super(AttributePath, self)._serialize(value)
-        return {ATTR_TYPE_MAP[self.attribute.attr_type]: self.attribute.serialize(value)}
-
-
 class AttributeContainerMeta(type):
 
     def __init__(cls, name, bases, attrs):

pynamodb/connection/base.py

@@ -43,9 +43,10 @@
     TableError, QueryError, PutError, DeleteError, UpdateError, GetError, ScanError, TableDoesNotExist,
     VerboseClientError
 )
-from pynamodb.expressions.condition import Condition, Path
+from pynamodb.expressions.condition import Condition
+from pynamodb.expressions.operand import Path
 from pynamodb.expressions.projection import create_projection_expression
-from pynamodb.expressions.update import AddAction, DeleteAction, RemoveAction, SetAction, Update
+from pynamodb.expressions.update import Update
 from pynamodb.settings import get_settings_value
 from pynamodb.signals import pre_dynamodb_send, post_dynamodb_send
 from pynamodb.types import HASH, RANGE
@@ -870,6 +871,7 @@ def update_item(self,
         update_expression = Update()
         # We sort the keys here for determinism. This is mostly done to simplify testing.
         for key in sorted(attribute_updates.keys()):
+            path = Path([key])
             update = attribute_updates[key]
             action = update.get(ACTION)
             if action not in ATTR_UPDATE_ACTIONS:
@@ -880,11 +882,12 @@ def update_item(self,
                 attr_type = self.get_attribute_type(table_name, key, value)
             value = {attr_type: value}
             if action == DELETE:
-                action = RemoveAction(key) if attr_type is None else DeleteAction(key, value)
+                action = path.remove() if attr_type is None else path.difference_update(value)
             elif action == PUT:
-                action = SetAction(key, value)
+                action = path.set(value)
             else:
-                action = AddAction(key, value)
+                # right now update() returns an AddAction
+                action = path.update(value)
             update_expression.add_action(action)
         operation_kwargs[UPDATE_EXPRESSION] = update_expression.serialize(name_placeholders, expression_attribute_values)
 

pynamodb/expressions/condition.py

@@ -1,138 +1,16 @@
 from pynamodb.constants import (
-    AND, ATTR_TYPE_MAP, BETWEEN, BINARY_SHORT, IN, NUMBER_SHORT, OR, SHORT_ATTR_TYPES, STRING_SHORT
+    AND, BETWEEN, BINARY_SHORT, IN, NUMBER_SHORT, OR, SHORT_ATTR_TYPES, STRING_SHORT
 )
 from pynamodb.expressions.util import get_value_placeholder, substitute_names
-from six import string_types
 from six.moves import range
 
 
-class Operand(object):
-    """
-    Operand is the base class for objects that support creating conditions from comparators.
-    """
-
-    def __eq__(self, other):
-        return self._compare('=', other)
-
-    def __ne__(self, other):
-        return self._compare('<>', other)
-
-    def __lt__(self, other):
-        return self._compare('<', other)
-
-    def __le__(self, other):
-        return self._compare('<=', other)
-
-    def __gt__(self, other):
-        return self._compare('>', other)
-
-    def __ge__(self, other):
-        return self._compare('>=', other)
-
-    def _compare(self, operator, other):
-        return Condition(self, operator, self._serialize(other))
-
-    def between(self, lower, upper):
-        # This seemed preferable to other options such as merging value1 <= attribute & attribute <= value2
-        # into one condition expression. DynamoDB only allows a single sort key comparison and having this
-        # work but similar expressions like value1 <= attribute & attribute < value2 fail seems too brittle.
-        return Between(self, self._serialize(lower), self._serialize(upper))
-
-    def is_in(self, *values):
-        values = [self._serialize(value) for value in values]
-        return In(self, *values)
-
-    def _serialize(self, value):
-        # Check to see if value is already serialized
-        if isinstance(value, dict) and len(value) == 1 and list(value.keys())[0] in SHORT_ATTR_TYPES:
-            return value
-        # Serialize value based on its type
-        from pynamodb.attributes import _get_class_for_serialize
-        attr_class = _get_class_for_serialize(value)
-        return {ATTR_TYPE_MAP[attr_class.attr_type]: attr_class.serialize(value)}
-
-
-class Size(Operand):
-    """
-    Size is a special operand that represents the result of calling the 'size' function on a Path operand.
-    """
-
-    def __init__(self, path):
-        # prevent circular import -- AttributePath imports Path
-        from pynamodb.attributes import Attribute, AttributePath
-        if isinstance(path, Path):
-            self.path = Path
-        elif isinstance(path, Attribute):
-            self.path = AttributePath(path)
-        else:
-            self.path = Path(path)
-
-    def _serialize(self, value):
-        if not isinstance(value, int):
-            raise TypeError("size must be compared to an integer, not {0}".format(type(value).__name__))
-        return {NUMBER_SHORT: str(value)}
-
-    def __str__(self):
-        return "size({0})".format(self.path)
-
-    def __repr__(self):
-        return "Size({0})".format(repr(self.path))
-
-
 # match dynamo function syntax: size(path)
 def size(path):
+    from pynamodb.expressions.operand import Size
     return Size(path)
 
 
-class Path(Operand):
-    """
-    Path is an operand that represents either an attribute name or document path.
-    In addition to supporting comparisons, Path also supports creating conditions from functions.
-    """
-
-    def __init__(self, path):
-        if not path:
-            raise ValueError("path cannot be empty")
-        self.path = path.split('.') if isinstance(path, string_types) else list(path)
-
-    def __getitem__(self, idx):
-        # list dereference operator
-        if not isinstance(idx, int):
-            raise TypeError("list indices must be integers, not {0}".format(type(idx).__name__))
-        element_path = Path(self.path)  # copy the document path before indexing last element
-        element_path.path[-1] = '{0}[{1}]'.format(self.path[-1], idx)
-        return element_path
-
-    def exists(self):
-        return Exists(self)
-
-    def does_not_exist(self):
-        return NotExists(self)
-
-    def is_type(self, attr_type):
-        return IsType(self, attr_type)
-
-    def startswith(self, prefix):
-        # A 'pythonic' replacement for begins_with to match string behavior (e.g. "foo".startswith("f"))
-        return BeginsWith(self, self._serialize(prefix))
-
-    def contains(self, item):
-        return Contains(self, self._serialize(item))
-
-    def __str__(self):
-        # Quote the path to illustrate that any dot characters are not dereference operators.
-        quoted_path = [self._quote_path(segment) if '.' in segment else segment for segment in self.path]
-        return '.'.join(quoted_path)
-
-    def __repr__(self):
-        return "Path({0})".format(self.path)
-
-    @staticmethod
-    def _quote_path(path):
-        path, sep, rem = path.partition('[')
-        return repr(path) + sep + rem
-
-
 class Condition(object):
     format_string = '{path} {operator} {0}'
 
@@ -151,6 +29,7 @@ def serialize(self, placeholder_names, expression_attribute_values):
         return self.format_string.format(*values, path=path, operator=self.operator)
 
     def _get_path(self, path, placeholder_names):
+        from pynamodb.expressions.operand import Path, Size
         if isinstance(path, Path):
             return substitute_names(path.path, placeholder_names)
         elif isinstance(path, Size):