Make get_attributes public (#452)

Being able to dynamically introspect Model classes is valuable for tasks
such as validation. This commit converts the underscore-prefixed private
method `_get_attributes` into a public method.

Author: Zack Hsi

pynamodb/attributes.py

@@ -7,6 +7,7 @@
 from base64 import b64encode, b64decode
 from copy import deepcopy
 from datetime import datetime
+import warnings
 from dateutil.parser import parse
 from dateutil.tz import tzutc
 from inspect import getargspec
@@ -226,6 +227,16 @@ def _get_attributes(cls):
         """
         Returns the attributes of this class as a mapping from `python_attr_name` => `attribute`.
 
+        :rtype: dict[str, Attribute]
+        """
+        warnings.warn("`Model._get_attributes` is deprecated in favor of `Model.get_attributes` now")
+        return cls.get_attributes()
+
+    @classmethod
+    def get_attributes(cls):
+        """
+        Returns the attributes of this class as a mapping from `python_attr_name` => `attribute`.
+
         :rtype: dict[str, Attribute]
         """
         return cls._attributes
@@ -243,7 +254,7 @@ def _set_defaults(self):
         """
         Sets and fields that provide a default value
         """
-        for name, attr in self._get_attributes().items():
+        for name, attr in self.get_attributes().items():
             default = attr.default
             if callable(default):
                 value = default()
@@ -257,7 +268,7 @@ def _set_attributes(self, **attributes):
         Sets the attributes for this object
         """
         for attr_name, attr_value in six.iteritems(attributes):
-            if attr_name not in self._get_attributes():
+            if attr_name not in self.get_attributes():
                 raise ValueError("Attribute {0} specified does not exist".format(attr_name))
             setattr(self, attr_name, attr_value)
 
@@ -636,7 +647,7 @@ def __init__(self, **attributes):
         #     cannot raise a ValueError (if this assumption is wrong, calling `_make_attribute` removes them)
         #   - the names of all attributes in self.attribute_kwargs match attributes defined on the class
         if self.attribute_kwargs and (
-                attributes or self.is_raw() or all(arg in self._get_attributes() for arg in self.attribute_kwargs)):
+                attributes or self.is_raw() or all(arg in self.get_attributes() for arg in self.attribute_kwargs)):
             self._set_attributes(**self.attribute_kwargs)
 
     def _is_attribute_container(self):
@@ -655,7 +666,7 @@ def _make_attribute(self):
         del self.attribute_kwargs
         del self.attribute_values
         Attribute.__init__(self, **kwargs)
-        for name, attr in self._get_attributes().items():
+        for name, attr in self.get_attributes().items():
             # Set a local attribute with the same name that shadows the class attribute.
             # Because attr is a data descriptor and the attribute already exists on the class,
             # we have to store the local copy directly into __dict__ to prevent calling attr.__set__.
@@ -667,7 +678,7 @@ def _update_attribute_paths(self, path_segment):
         # WARNING! This function is only intended to be called from the AttributeContainerMeta metaclass.
         if self._is_attribute_container():
             raise AssertionError("MapAttribute._update_attribute_paths called before MapAttribute._make_attribute")
-        for name in self._get_attributes().keys():
+        for name in self.get_attributes().keys():
             local_attr = self.__dict__[name]
             local_attr.attr_path.insert(0, path_segment)
             if isinstance(local_attr, MapAttribute):
@@ -754,7 +765,7 @@ def is_correctly_typed(self, key, attr):
         return True  # TODO: check that the actual type of `value` meets requirements of `attr`
 
     def validate(self):
-        return all(self.is_correctly_typed(k, v) for k, v in six.iteritems(self._get_attributes()))
+        return all(self.is_correctly_typed(k, v) for k, v in six.iteritems(self.get_attributes()))
 
     def serialize(self, values):
         rval = {}
@@ -771,7 +782,7 @@ def serialize(self, values):
                 attr_key = _get_key_for_serialize(v)
 
             # If this is a subclassed MapAttribute, there may be an alternate attr name
-            attr = self._get_attributes().get(k)
+            attr = self.get_attributes().get(k)
             attr_name = attr.attr_name if attr else k
 
             serialized = attr_class.serialize(v)
@@ -824,13 +835,13 @@ def _should_skip(self, value):
     @classmethod
     def _get_serialize_class(cls, key, value):
         if not cls.is_raw():
-            return cls._get_attributes().get(key)
+            return cls.get_attributes().get(key)
         return _get_class_for_serialize(value)
 
     @classmethod
     def _get_deserialize_class(cls, key, value):
         if not cls.is_raw():
-            return cls._get_attributes().get(key)
+            return cls.get_attributes().get(key)
         return _get_class_for_deserialize(value)
 
 

pynamodb/models.py

@@ -244,7 +244,7 @@ def __init__(self, hash_key=None, range_key=None, **attributes):
 
     @classmethod
     def has_map_or_list_attributes(cls):
-        for attr_value in cls._get_attributes().values():
+        for attr_value in cls.get_attributes().values():
             if isinstance(attr_value, MapAttribute) or isinstance(attr_value, ListAttribute):
                 return True
         return False
@@ -356,7 +356,7 @@ def update_item(self, attribute, value=None, action=None, condition=None, condit
         self._conditional_operator_check(conditional_operator)
         args, save_kwargs = self._get_save_args(null_check=False)
         attribute_cls = None
-        for attr_name, attr_cls in self._get_attributes().items():
+        for attr_name, attr_cls in self.get_attributes().items():
             if attr_name == attribute:
                 attribute_cls = attr_cls
                 break
@@ -387,7 +387,7 @@ def update_item(self, attribute, value=None, action=None, condition=None, condit
 
         for name, value in data.get(ATTRIBUTES).items():
             attr_name = self._dynamo_to_python_attr(name)
-            attr = self._get_attributes().get(attr_name)
+            attr = self.get_attributes().get(attr_name)
             if attr:
                 setattr(self, attr_name, attr.deserialize(attr.get_value(value)))
         return data
@@ -423,7 +423,7 @@ def update(self, attributes=None, actions=None, condition=None, conditional_oper
         if expected_values:
             kwargs['expected'] = self._build_expected_values(expected_values, UPDATE_FILTER_OPERATOR_MAP)
 
-        attrs = self._get_attributes()
+        attrs = self.get_attributes()
         attributes = attributes or {}
         for attr, params in attributes.items():
             attribute_cls = attrs[attr]
@@ -439,7 +439,7 @@ def update(self, attributes=None, actions=None, condition=None, conditional_oper
         data = self._get_connection().update_item(*args, **kwargs)
         for name, value in data[ATTRIBUTES].items():
             attr_name = self._dynamo_to_python_attr(name)
-            attr = self._get_attributes().get(attr_name)
+            attr = self.get_attributes().get(attr_name)
             if attr:
                 setattr(self, attr_name, attr.deserialize(attr.get_value(value)))
         return data
@@ -511,19 +511,19 @@ def from_raw_data(cls, data):
         hash_key_type = cls._get_meta_data().get_attribute_type(hash_keyname)
         hash_key = mutable_data.pop(hash_keyname).get(hash_key_type)
 
-        hash_key_attr = cls._get_attributes().get(cls._dynamo_to_python_attr(hash_keyname))
+        hash_key_attr = cls.get_attributes().get(cls._dynamo_to_python_attr(hash_keyname))
 
         hash_key = hash_key_attr.deserialize(hash_key)
         args = (hash_key,)
         kwargs = {}
         if range_keyname:
-            range_key_attr = cls._get_attributes().get(cls._dynamo_to_python_attr(range_keyname))
+            range_key_attr = cls.get_attributes().get(cls._dynamo_to_python_attr(range_keyname))
             range_key_type = cls._get_meta_data().get_attribute_type(range_keyname)
             range_key = mutable_data.pop(range_keyname).get(range_key_type)
             kwargs['range_key'] = range_key_attr.deserialize(range_key)
         for name, value in mutable_data.items():
             attr_name = cls._dynamo_to_python_attr(name)
-            attr = cls._get_attributes().get(attr_name, None)
+            attr = cls.get_attributes().get(attr_name, None)
             if attr:
                 kwargs[attr_name] = attr.deserialize(attr.get_value(value))
         return cls(*args, **kwargs)
@@ -557,12 +557,12 @@ def count(cls,
         if index_name:
             hash_key = cls._index_classes[index_name]._hash_key_attribute().serialize(hash_key)
             key_attribute_classes = cls._index_classes[index_name]._get_attributes()
-            non_key_attribute_classes = cls._get_attributes()
+            non_key_attribute_classes = cls.get_attributes()
         else:
             hash_key = cls._serialize_keys(hash_key)[0]
-            non_key_attribute_classes = dict(cls._get_attributes())
-            key_attribute_classes = dict(cls._get_attributes())
-            for name, attr in cls._get_attributes().items():
+            non_key_attribute_classes = dict(cls.get_attributes())
+            key_attribute_classes = dict(cls.get_attributes())
+            for name, attr in cls.get_attributes().items():
                 if attr.is_range_key or attr.is_hash_key:
                     key_attribute_classes[name] = attr
                 else:
@@ -636,12 +636,12 @@ def query(cls,
         if index_name:
             hash_key = cls._index_classes[index_name]._hash_key_attribute().serialize(hash_key)
             key_attribute_classes = cls._index_classes[index_name]._get_attributes()
-            non_key_attribute_classes = cls._get_attributes()
+            non_key_attribute_classes = cls.get_attributes()
         else:
             hash_key = cls._serialize_keys(hash_key)[0]
             non_key_attribute_classes = {}
             key_attribute_classes = {}
-            for name, attr in cls._get_attributes().items():
+            for name, attr in cls.get_attributes().items():
                 if attr.is_range_key or attr.is_hash_key:
                     key_attribute_classes[name] = attr
                 else:
@@ -729,7 +729,7 @@ def rate_limited_scan(cls,
         key_filter, scan_filter = cls._build_filters(
             SCAN_OPERATOR_MAP,
             non_key_operator_map=SCAN_OPERATOR_MAP,
-            key_attribute_classes=cls._get_attributes(),
+            key_attribute_classes=cls.get_attributes(),
             filters=filters
         )
         key_filter.update(scan_filter)
@@ -786,7 +786,7 @@ def scan(cls,
         key_filter, scan_filter = cls._build_filters(
             SCAN_OPERATOR_MAP,
             non_key_operator_map=SCAN_OPERATOR_MAP,
-            key_attribute_classes=cls._get_attributes(),
+            key_attribute_classes=cls.get_attributes(),
             filters=filters
         )
         key_filter.update(scan_filter)
@@ -950,7 +950,7 @@ def _build_expected_values(cls, expected_values, operator_map=None):
         :param expected_values: A list of expected values
         """
         expected_values_result = {}
-        attributes = cls._get_attributes()
+        attributes = cls.get_attributes()
         filters = {}
         for attr_name, attr_value in expected_values.items():
             attr_cond = VALUE
@@ -1109,7 +1109,7 @@ def _get_schema(cls):
             pythonic(ATTR_DEFINITIONS): [],
             pythonic(KEY_SCHEMA): []
         }
-        for attr_name, attr_cls in cls._get_attributes().items():
+        for attr_name, attr_cls in cls.get_attributes().items():
             if attr_cls.is_hash_key or attr_cls.is_range_key:
                 schema[pythonic(ATTR_DEFINITIONS)].append({
                     pythonic(ATTR_NAME): attr_cls.attr_name,
@@ -1202,7 +1202,7 @@ def _range_key_attribute(cls):
         """
         Returns the attribute class for the hash key
         """
-        attributes = cls._get_attributes()
+        attributes = cls.get_attributes()
         range_keyname = cls._get_meta_data().range_keyname
         if range_keyname:
             attr = attributes[cls._dynamo_to_python_attr(range_keyname)]
@@ -1215,7 +1215,7 @@ def _hash_key_attribute(cls):
         """
         Returns the attribute class for the hash key
         """
-        attributes = cls._get_attributes()
+        attributes = cls.get_attributes()
         hash_keyname = cls._get_meta_data().hash_keyname
         return attributes[cls._dynamo_to_python_attr(hash_keyname)]
 
@@ -1301,7 +1301,7 @@ def _deserialize(self, attrs):
 
         :param attrs: A dictionary of attributes to update this item with.
         """
-        for name, attr in self._get_attributes().items():
+        for name, attr in self.get_attributes().items():
             value = attrs.get(attr.attr_name, None)
             if value is not None:
                 value = value.get(ATTR_TYPE_MAP[attr.attr_type], None)
@@ -1318,7 +1318,7 @@ def _serialize(self, attr_map=False, null_check=True):
         """
         attributes = pythonic(ATTRIBUTES)
         attrs = {attributes: {}}
-        for name, attr in self._get_attributes().items():
+        for name, attr in self.get_attributes().items():
             value = getattr(self, name)
             if isinstance(value, MapAttribute):
                 if not value.validate():