fix(ndb): replace asserts in production code with explicit checks

Author: chalmerlowe

packages/google-cloud-ndb/google/cloud/ndb/_datastore_query.py

@@ -342,8 +342,10 @@ def has_next_async(self):
         if self._batch is None:
             yield self._next_batch()  # First time
 
-        assert self._batch is not None
-        assert self._index is not None
+        if self._batch is None:
+            raise TypeError("self._batch cannot be None")
+        if self._index is None:
+            raise TypeError("self._index cannot be None")
         if self._index < len(self._batch):
             raise tasklets.Return(True)
 
@@ -425,8 +427,10 @@ def next(self):
             self._cursor_before = None
             raise StopIteration
 
-        assert self._batch is not None
-        assert self._index is not None
+        if self._batch is None:
+            raise TypeError("self._batch cannot be None")
+        if self._index is None:
+            raise TypeError("self._index cannot be None")
         # Won't block
         next_result = self._batch[self._index]
         self._index += 1
@@ -560,7 +564,8 @@ def next(self):
         if not self.has_next():
             raise StopIteration()
 
-        assert self._next_result is not None
+        if self._next_result is None:
+            raise TypeError("self._next_result cannot be None")
         # Won't block
         next_result = self._next_result
         self._next_result = None
@@ -725,7 +730,8 @@ def next(self):
         if not self.has_next():
             raise StopIteration()
 
-        assert self._next_result is not None
+        if self._next_result is None:
+            raise TypeError("self._next_result cannot be None")
         # Won't block
         next_result = self._next_result
         self._next_result = None

packages/google-cloud-ndb/google/cloud/ndb/_gql.py

@@ -409,7 +409,8 @@ def _AddProcessedParameterFilter(self, identifier, condition, operator, paramete
         if identifier.lower() == "ancestor":
             self._has_ancestor = True
             filter_rule = (self._ANCESTOR, "is")
-            assert condition.lower() == "is"
+            if condition.lower() != "is":
+                raise ValueError("condition must be 'is'")
 
         if operator == "list" and condition.lower() not in ["in", "not_in"]:
             self._Error("Only IN can process a list of values, given '%s'" % condition)

packages/google-cloud-ndb/google/cloud/ndb/model.py

@@ -611,7 +611,8 @@ def new_entity(key):
                 subvalue = value
                 value = structprop._get_base_value(entity)
                 if value in (None, []):  # empty list for repeated props
-                    assert structprop._model_class is not None
+                    if structprop._model_class is None:
+                        raise TypeError("structprop._model_class cannot be None")
                     kind = structprop._model_class._get_kind()
                     key = key_module.Key(kind, None)
                     if structprop._repeated:
@@ -642,7 +643,8 @@ def new_entity(key):
                         # the other entries in the value list
                         while len(subvalue) > len(value):
                             # Need to make some more subentities
-                            assert structprop._model_class is not None
+                            if structprop._model_class is None:
+                                raise TypeError("structprop._model_class cannot be None")
                             expando_kind = structprop._model_class._get_kind()
                             expando_key = key_module.Key(expando_kind, None)
                             value.append(new_entity(expando_key._key))
@@ -2055,7 +2057,8 @@ def _legacy_deserialize(self, entity, p, unused_depth=1):
         if self._repeated:
             if self._has_value(entity):
                 value = self._retrieve_value(entity)
-                assert isinstance(value, list), repr(value)
+                if not isinstance(value, list):
+                    raise TypeError(f"Expected list, got {type(value)}")
                 value.append(val)
             else:
                 # We promote single values to lists if we are a list property
@@ -4161,7 +4164,8 @@ def _get_for_dict(self, entity):
 
     def __getattr__(self, attrname):
         """Dynamically get a subproperty."""
-        assert self._model_class is not None
+        if self._model_class is None:
+            raise TypeError("self._model_class cannot be None")
         # Optimistically try to use the dict key.
         prop = self._model_class._properties.get(attrname)
 
@@ -4180,7 +4184,8 @@ def __getattr__(self, attrname):
             )
 
         prop_copy = copy.copy(prop)
-        assert self._name is not None
+        if self._name is None:
+            raise TypeError("self._name cannot be None")
         prop_copy._name = self._name + "." + prop_copy._name
 
         # Cache the outcome, so subsequent requests for the same attribute
@@ -4211,7 +4216,8 @@ def _comparison(self, op, value):
         value = self._do_validate(value)
         filters = []
         match_keys = []
-        assert self._model_class is not None
+        if self._model_class is None:
+            raise TypeError("self._model_class cannot be None")
         for prop_name, prop in self._model_class._properties.items():
             subvalue = prop._get_value(value)
             if prop._repeated:
@@ -4264,7 +4270,8 @@ def _IN(self, value, server_op=None):
     IN = _IN
 
     def _validate(self, value):
-        assert self._model_class is not None
+        if self._model_class is None:
+            raise TypeError("self._model_class cannot be None")
         if isinstance(value, dict):
             # A dict is assumed to be the result of a _to_dict() call.
             return self._model_class(**value)
@@ -4325,7 +4332,8 @@ def _check_property(self, rest=None, require_indexed=True):
             raise InvalidPropertyError(
                 "Structured property %s requires a subproperty" % self._name
             )
-        assert self._model_class is not None
+        if self._model_class is None:
+            raise TypeError("self._model_class cannot be None")
         self._model_class._check_properties([rest], require_indexed=require_indexed)
 
     def _to_base_type(self, value):
@@ -4340,7 +4348,8 @@ def _to_base_type(self, value):
         Raises:
             TypeError: If ``value`` is not the correct ``Model`` type.
         """
-        assert self._model_class is not None
+        if self._model_class is None:
+            raise TypeError("self._model_class cannot be None")
         if not isinstance(value, self._model_class):
             raise TypeError(
                 "Cannot convert to protocol buffer. Expected {} value; "
@@ -4475,7 +4484,8 @@ def _validate(self, value):
         Raises:
             exceptions.BadValueError: If ``value`` is not a given class.
         """
-        assert self._model_class is not None
+        if self._model_class is None:
+            raise TypeError("self._model_class cannot be None")
         if isinstance(value, dict):
             # A dict is assumed to be the result of a _to_dict() call.
             return self._model_class(**value)
@@ -4504,7 +4514,8 @@ def _to_base_type(self, value):
         Raises:
             TypeError: If ``value`` is not the correct ``Model`` type.
         """
-        assert self._model_class is not None
+        if self._model_class is None:
+            raise TypeError("self._model_class cannot be None")
         if not isinstance(value, self._model_class):
             raise TypeError(
                 "Cannot convert to bytes expected {} value; "
@@ -4522,7 +4533,8 @@ def _from_base_type(self, value):
         Returns:
             The converted value with given class.
         """
-        assert self._model_class is not None
+        if self._model_class is None:
+            raise TypeError("self._model_class cannot be None")
         if isinstance(value, bytes):
             pb = entity_pb2.Entity()
             pb._pb.MergeFromString(value)
@@ -4699,7 +4711,8 @@ def _get_value(self, entity):
         # UnprojectedPropertyError which will just bubble up.
         if entity._projection and self._name in entity._projection:
             return super(ComputedProperty, self)._get_value(entity)
-        assert self._func is not None
+        if self._func is None:
+            raise TypeError("self._func cannot be None")
         value = self._func(entity)
         self._store_value(entity, value)
         return value
@@ -5035,7 +5048,8 @@ def _fake_property(self, p, next, indexed=True):
         # A custom 'meaning' for compressed properties.
         _MEANING_URI_COMPRESSED = "ZLIB"
         self._clone_properties()
-        assert self._properties is not None
+        if self._properties is None:
+            raise TypeError("self._properties cannot be None")
         prop: Property
         if p.name() != next.encode("utf-8") and not p.name().endswith(
             b"." + next.encode("utf-8")
@@ -5349,13 +5363,15 @@ def _check_properties(cls, property_names, require_indexed=True):
             InvalidPropertyError: if one of the properties is invalid.
             AssertionError: if the argument is not a list or tuple of strings.
         """
-        assert isinstance(property_names, (list, tuple)), repr(property_names)
+        if not isinstance(property_names, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(property_names)}")
         for name in property_names:
             if "." in name:
                 name, rest = name.split(".", 1)
             else:
                 rest = None
-            assert cls._properties is not None
+            if cls._properties is None:
+                raise TypeError("cls._properties cannot be None")
             prop = cls._properties.get(name)
             if prop is None:
                 raise InvalidPropertyError("Unknown property {}".format(name))
@@ -6199,7 +6215,8 @@ def _to_dict(self, include=None, exclude=None):
                 to exclude. Default is to not exclude any names.
         """
         values = {}
-        assert self._properties is not None
+        if self._properties is None:
+            raise TypeError("self._properties cannot be None")
         for prop in self._properties.values():
             name = prop._code_name
             if include is not None and name not in include:
@@ -6221,7 +6238,8 @@ def _to_dict(self, include=None, exclude=None):
     def _code_name_from_stored_name(cls, name):
         """Return the code name from a property when it's different from the
         stored name. Used in deserialization from datastore."""
-        assert cls._properties is not None
+        if cls._properties is None:
+            raise TypeError("cls._properties cannot be None")
         if name in cls._properties:
             return cls._properties[name]._code_name
 
@@ -6323,14 +6341,16 @@ def _set_attributes(self, kwds):
             setattr(self, name, value)
 
     def __getattr__(self, name):
-        assert self._properties is not None
+        if self._properties is None:
+            raise TypeError("self._properties cannot be None")
         prop = self._properties.get(name)
         if prop is None:
             return super(Expando, self).__getattribute__(name)
         return prop._get_value(self)
 
     def __setattr__(self, name, value):
-        assert self._properties is not None
+        if self._properties is None:
+            raise TypeError("self._properties cannot be None")
         if (
             name.startswith("_")
             or isinstance(getattr(self.__class__, name, None), (Property, property))
@@ -6365,7 +6385,8 @@ def __setattr__(self, name, value):
         prop._set_value(self, value)
 
     def __delattr__(self, name):
-        assert self._properties is not None
+        if self._properties is None:
+            raise TypeError("self._properties cannot be None")
         if name.startswith("_") or isinstance(
             getattr(self.__class__, name, None), (Property, property)
         ):