From 64b0828fe3d4d84ac9a80c4e0d4333f90de1d56f Mon Sep 17 00:00:00 2001
From: Kaushik ASP <aspkaushik@gmail.com>
Date: Thu, 20 Sep 2018 14:32:20 +0530
Subject: [PATCH] fallback

---
 graphene/pyutils/version.py          | 13 +++-----
 graphene/relay/connection.py         | 37 +++++++++-----------
 graphene/relay/mutation.py           | 16 ++++-----
 graphene/relay/node.py               |  3 +-
 graphene/types/argument.py           |  8 ++---
 graphene/types/base.py               |  7 ++--
 graphene/types/datetime.py           | 20 ++++-------
 graphene/types/decimal.py            |  5 ++-
 graphene/types/dynamic.py            |  3 +-
 graphene/types/field.py              | 23 +++++--------
 graphene/types/mountedtype.py        |  7 ++--
 graphene/types/mutation.py           |  7 ++--
 graphene/types/objecttype.py         | 19 ++++-------
 graphene/types/schema.py             | 16 +++------
 graphene/types/structures.py         |  9 ++---
 graphene/types/typemap.py            | 50 +++++++++++-----------------
 graphene/types/union.py              |  7 ++--
 graphene/types/uuid.py               |  7 ++--
 graphene/utils/annotate.py           |  9 ++---
 graphene/utils/comparison_helper.py  |  3 --
 graphene/utils/subclass_with_meta.py |  9 ++---
 21 files changed, 101 insertions(+), 177 deletions(-)
 delete mode 100644 graphene/utils/comparison_helper.py

diff --git a/graphene/pyutils/version.py b/graphene/pyutils/version.py
index ed2d16b1..326e59bd 100644
--- a/graphene/pyutils/version.py
+++ b/graphene/pyutils/version.py
@@ -3,7 +3,6 @@ from __future__ import unicode_literals
 import datetime
 import os
 import subprocess
-from ..utils.comparison_helper import raise_assertion_if_not
 
 
 def get_version(version=None):
@@ -45,13 +44,11 @@ def get_complete_version(version=None):
     if version is None:
         from graphene import VERSION as version
     else:
-        raise_assertion_if_not(
-            condition=len(version) is 5, message="Wrong tuple provided"
-        )
-        raise_assertion_if_not(
-            condition=version[3] in ("alpha", "beta", "rc", "final"),
-            message="Version not correct.",
-        )
+        if len(version) is not 5:
+            raise AssertionError("Wrong tuple provided")
+
+        if not version[3] in ("alpha", "beta", "rc", "final"):
+            raise AssertionError("Version not correct.")
 
     return version
 
diff --git a/graphene/relay/connection.py b/graphene/relay/connection.py
index 3a96a447..a61a6ee5 100644
--- a/graphene/relay/connection.py
+++ b/graphene/relay/connection.py
@@ -9,7 +9,6 @@ from ..types.field import Field
 from ..types.objecttype import ObjectType, ObjectTypeOptions
 from ..utils.thenables import maybe_thenable
 from .node import is_node
-from ..utils.comparison_helper import raise_assertion_if_not
 
 
 class PageInfo(ObjectType):
@@ -53,18 +52,15 @@ class Connection(ObjectType):
     @classmethod
     def __init_subclass_with_meta__(cls, node=None, name=None, **options):
         _meta = ConnectionOptions(cls)
-        raise_assertion_if_not(
-            condition=node,
-            message="You have to provide a node in {}.Meta".format(cls.__name__),
-        )
-        raise_assertion_if_not(
-            condition=issubclass(
-                node, (Scalar, Enum, ObjectType, Interface, Union, NonNull)
-            ),
-            message=('Received incompatible node "{}" for Connection {}.').format(
+        if not node:
+            raise AssertionError(
+                                 "You have to provide a node in {}.Meta".format(cls.__name__)
+                                 )
+
+        if not issubclass(node, (Scalar, Enum, ObjectType, Interface, Union, NonNull)):
+            raise AssertionError('Received incompatible node "{}" for Connection {}.'.format(
                 node, cls.__name__
-            ),
-        )
+            ))
 
         base_name = re.sub("Connection$", "", name or cls.__name__) or node._meta.name
         if not name:
@@ -139,12 +135,11 @@ class IterableConnectionField(Field):
                 "Read more: https://github.com/graphql-python/graphene/blob/v2.0.0/UPGRADE-v2.0.md#node-connections"
             )
 
-        raise_assertion_if_not(
-            condition=issubclass(connection_type, Connection),
-            message='{} type have to be a subclass of Connection. Received "{}".'.format(
+        if not issubclass(connection_type, Connection):
+            raise AssertionError('{} type have to be a subclass of Connection. Received "{}".'.format(
                 self.__class__.__name__, connection_type
-            ),
-        )
+            ))
+
         return type
 
     @classmethod
@@ -152,15 +147,13 @@ class IterableConnectionField(Field):
         if isinstance(resolved, connection_type):
             return resolved
 
-        raise_assertion_if_not(
-            condition=isinstance(resolved, Iterable),
-            message="""
+        if not isinstance(resolved, Iterable):
+            raise AssertionError("""
                 Resolved value from the connection field have to be iterable or instance of {}.
                 Received "{}"
             """.format(
                 connection_type, resolved
-            ),
-        )
+            ))
 
         connection = connection_from_list(
             resolved,
diff --git a/graphene/relay/mutation.py b/graphene/relay/mutation.py
index 792230c7..ab2f4b2e 100644
--- a/graphene/relay/mutation.py
+++ b/graphene/relay/mutation.py
@@ -17,11 +17,11 @@ class ClientIDMutation(Mutation):
         input_class = getattr(cls, "Input", None)
         base_name = re.sub("Payload$", "", name or cls.__name__)
 
-        raise_assertion_if_not(condition=not output, message="Can't specify any output")
+        if output:
+            raise AssertionError("Can't specify any output")
 
-        raise_assertion_if_not(
-            condition=not arguments, message="Can't specify any arguments"
-        )
+        if arguments:
+            raise AssertionError("Can't specify any arguments")
 
         bases = (InputObjectType,)
         if input_class:
@@ -44,11 +44,9 @@ class ClientIDMutation(Mutation):
         )
         mutate_and_get_payload = getattr(cls, "mutate_and_get_payload", None)
         if cls.mutate and cls.mutate.__func__ == ClientIDMutation.mutate.__func__:
-            raise_assertion_if_not(
-                condition=mutate_and_get_payload,
-                message="{name}.mutate_and_get_payload method is required"
-                " in a ClientIDMutation.".format(name=name or cls.__name__),
-            )
+            if not (mutate_and_get_payload):
+                raise AssertionError("{name}.mutate_and_get_payload method is required"
+                " in a ClientIDMutation.".format(name=name or cls.__name__))
 
         if not name:
             name = "{}Payload".format(base_name)
diff --git a/graphene/relay/node.py b/graphene/relay/node.py
index d9c4c0f6..e195d5cf 100644
--- a/graphene/relay/node.py
+++ b/graphene/relay/node.py
@@ -49,7 +49,8 @@ class GlobalID(Field):
 
 class NodeField(Field):
     def __init__(self, node, type=False, deprecation_reason=None, name=None, **kwargs):
-        assert issubclass(node, Node), "NodeField can only operate in Nodes"
+        if not issubclass(node, Node):
+            raise AssertionError("NodeField can only operate in Nodes")
         self.node_type = node
         self.field_type = type
 
diff --git a/graphene/types/argument.py b/graphene/types/argument.py
index 11a37767..a4c19aa8 100644
--- a/graphene/types/argument.py
+++ b/graphene/types/argument.py
@@ -5,7 +5,6 @@ from .dynamic import Dynamic
 from .mountedtype import MountedType
 from .structures import NonNull
 from .utils import get_type
-from ..utils.comparison_helper import raise_assertion_if_not
 
 
 class Argument(MountedType):
@@ -74,10 +73,9 @@ def to_arguments(args, extra_args=None):
             raise ValueError('Unknown argument "{}".'.format(default_name))
 
         arg_name = default_name or arg.name
-        raise_assertion_if_not(
-            condition=arg_name not in arguments,
-            message='More than one Argument have same name "{}".'.format(arg_name),
-        )
+        if arg_name in arguments:
+            raise AssertionError('More than one Argument have same name "{}".'.format(arg_name))
+
         arguments[arg_name] = arg
 
     return arguments
diff --git a/graphene/types/base.py b/graphene/types/base.py
index 852737bf..ac76f401 100644
--- a/graphene/types/base.py
+++ b/graphene/types/base.py
@@ -1,6 +1,5 @@
 from ..utils.subclass_with_meta import SubclassWithMeta
 from ..utils.trim_docstring import trim_docstring
-from ..utils.comparison_helper import raise_assertion_if_not
 
 
 class BaseOptions(object):
@@ -32,9 +31,9 @@ class BaseType(SubclassWithMeta):
 
     @classmethod
     def __init_subclass_with_meta__(cls, name=None, description=None, _meta=None):
-        raise_assertion_if_not(
-            condition="_meta" not in cls.__dict__, message="Can't assign directly meta"
-        )
+        if "_meta" in cls.__dict__:
+            raise AssertionError("Can't assign directly meta")
+
         if not _meta:
             return
         _meta.name = name or cls.__name__
diff --git a/graphene/types/datetime.py b/graphene/types/datetime.py
index 61d42b75..345605e7 100644
--- a/graphene/types/datetime.py
+++ b/graphene/types/datetime.py
@@ -6,7 +6,6 @@ from aniso8601 import parse_date, parse_datetime, parse_time
 from graphql.language import ast
 
 from .scalars import Scalar
-from ..utils.comparison_helper import raise_assertion_if_not
 
 
 class Date(Scalar):
@@ -20,10 +19,9 @@ class Date(Scalar):
     def serialize(date):
         if isinstance(date, datetime.datetime):
             date = date.date()
-        raise_assertion_if_not(
-            condition=isinstance(date, datetime.date),
-            message='Received not compatible date "{}"'.format(repr(date)),
-        )
+        if not isinstance(date, datetime.date):
+            raise AssertionError('Received not compatible date "{}"'.format(repr(date)))
+
         return date.isoformat()
 
     @classmethod
@@ -48,10 +46,8 @@ class DateTime(Scalar):
 
     @staticmethod
     def serialize(dt):
-        raise_assertion_if_not(
-            condition=isinstance(dt, (datetime.datetime, datetime.date)),
-            message='Received not compatible datetime "{}"'.format(repr(dt)),
-        )
+        if not isinstance(dt, (datetime.datetime, datetime.date)):
+            raise AssertionError('Received not compatible datetime "{}"'.format(repr(dt)))
         return dt.isoformat()
 
     @classmethod
@@ -76,10 +72,8 @@ class Time(Scalar):
 
     @staticmethod
     def serialize(time):
-        raise_assertion_if_not(
-            condition=isinstance(time, datetime.time),
-            message='Received not compatible time "{}"'.format(repr(time)),
-        )
+        if not isinstance(time, datetime.time):
+            raise AssertionError('Received not compatible time "{}"'.format(repr(time)))
         return time.isoformat()
 
     @classmethod
diff --git a/graphene/types/decimal.py b/graphene/types/decimal.py
index 2f99134d..1897d255 100644
--- a/graphene/types/decimal.py
+++ b/graphene/types/decimal.py
@@ -16,9 +16,8 @@ class Decimal(Scalar):
     def serialize(dec):
         if isinstance(dec, str):
             dec = _Decimal(dec)
-        assert isinstance(dec, _Decimal), 'Received not compatible Decimal "{}"'.format(
-            repr(dec)
-        )
+        if not isinstance(dec, _Decimal):
+            raise AssertionError('Received not compatible Decimal "{}"'.format(repr(dec)))
         return str(dec)
 
     @classmethod
diff --git a/graphene/types/dynamic.py b/graphene/types/dynamic.py
index 588c53bb..89951a3a 100644
--- a/graphene/types/dynamic.py
+++ b/graphene/types/dynamic.py
@@ -12,7 +12,8 @@ class Dynamic(MountedType):
 
     def __init__(self, type, with_schema=False, _creation_counter=None):
         super(Dynamic, self).__init__(_creation_counter=_creation_counter)
-        assert inspect.isfunction(type) or isinstance(type, partial)
+        if not inspect.isfunction(type) or isinstance(type, partial):
+            raise AssertionError
         self.type = type
         self.with_schema = with_schema
 
diff --git a/graphene/types/field.py b/graphene/types/field.py
index e0e009a2..313c24f3 100644
--- a/graphene/types/field.py
+++ b/graphene/types/field.py
@@ -7,7 +7,6 @@ from .mountedtype import MountedType
 from .structures import NonNull
 from .unmountedtype import UnmountedType
 from .utils import get_type
-from ..utils.comparison_helper import raise_assertion_if_not
 
 base_type = type
 
@@ -35,24 +34,18 @@ class Field(MountedType):
         **extra_args
     ):
         super(Field, self).__init__(_creation_counter=_creation_counter)
-        raise_assertion_if_not(
-            condition=not args or isinstance(args, Mapping),
-            message='Arguments in a field have to be a mapping, received "{}".'.format(
+        if not (not args or isinstance(args, Mapping)):
+            raise AssertionError('Arguments in a field have to be a mapping, received "{}".'.format(
                 args
-            ),
-        )
+            ))
 
-        raise_assertion_if_not(
-            condition=not (source and resolver),
-            message="A Field cannot have a source and a resolver in at the same time.",
-        )
+        if source and resolver:
+            raise AssertionError("A Field cannot have a source and a resolver in at the same time.")
 
-        raise_assertion_if_not(
-            condition=not callable(default_value),
-            message='The default value can not be a function but received "{}".'.format(
+        if callable(default_value):
+            raise AssertionError('The default value can not be a function but received "{}".'.format(
                 base_type(default_value)
-            ),
-        )
+            ))
 
         if required:
             type = NonNull(type)
diff --git a/graphene/types/mountedtype.py b/graphene/types/mountedtype.py
index bef31add..b039599a 100644
--- a/graphene/types/mountedtype.py
+++ b/graphene/types/mountedtype.py
@@ -1,6 +1,5 @@
 from ..utils.orderedtype import OrderedType
 from .unmountedtype import UnmountedType
-from ..utils.comparison_helper import raise_assertion_if_not
 
 
 class MountedType(OrderedType):
@@ -9,10 +8,8 @@ class MountedType(OrderedType):
         """
         Mount the UnmountedType instance
         """
-        raise_assertion_if_not(
-            condition=isinstance(unmounted, UnmountedType),
-            message="{} can't mount {}".format(cls.__name__, repr(unmounted)),
-        )
+        if not isinstance(unmounted, UnmountedType):
+            raise AssertionError("{} can't mount {}".format(cls.__name__, repr(unmounted)))
 
         return cls(
             unmounted.get_type(),
diff --git a/graphene/types/mutation.py b/graphene/types/mutation.py
index 76486e9f..a35b228c 100644
--- a/graphene/types/mutation.py
+++ b/graphene/types/mutation.py
@@ -6,7 +6,6 @@ from ..utils.props import props
 from .field import Field
 from .objecttype import ObjectType, ObjectTypeOptions
 from .utils import yank_fields_from_attrs
-from ..utils.comparison_helper import raise_assertion_if_not
 
 # For static type checking with Mypy
 MYPY = False
@@ -63,10 +62,8 @@ class Mutation(ObjectType):
 
         if not resolver:
             mutate = getattr(cls, "mutate", None)
-            raise_assertion_if_not(
-                condition=mutate,
-                message="All mutations must define a mutate method in it",
-            )
+            if not mutate:
+                raise AssertionError("All mutations must define a mutate method in it")
             resolver = get_unbound_function(mutate)
 
         if _meta.fields:
diff --git a/graphene/types/objecttype.py b/graphene/types/objecttype.py
index 08e765cc..044b0c92 100644
--- a/graphene/types/objecttype.py
+++ b/graphene/types/objecttype.py
@@ -4,7 +4,6 @@ from .base import BaseOptions, BaseType
 from .field import Field
 from .interface import Interface
 from .utils import yank_fields_from_attrs
-from ..utils.comparison_helper import raise_assertion_if_not
 
 # For static type checking with Mypy
 MYPY = False
@@ -40,24 +39,18 @@ class ObjectType(BaseType):
         fields = OrderedDict()
 
         for interface in interfaces:
-            raise_assertion_if_not(
-                condition=issubclass(interface, Interface),
-                message='All interfaces of {} must be a subclass of Interface. Received "{}".'.format(
+            if not issubclass(interface, Interface):
+                raise AssertionError('All interfaces of {} must be a subclass of Interface. Received "{}".'.format(
                     cls.__name__, interface
-                ),
-            )
+                ))
             fields.update(interface._meta.fields)
 
         for base in reversed(cls.__mro__):
             fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
 
-        raise_assertion_if_not(
-            condition=not (possible_types and cls.is_type_of),
-            message=(
-                "{name}.Meta.possible_types will cause type collision with {name}.is_type_of. "
-                "Please use one or other.".format(name=cls.__name__)
-            ),
-        )
+        if possible_types and cls.is_type_of:
+            raise AssertionError("{name}.Meta.possible_types will cause type collision with {name}.is_type_of. "
+                "Please use one or other.".format(name=cls.__name__))
 
         if _meta.fields:
             _meta.fields.update(fields)
diff --git a/graphene/types/schema.py b/graphene/types/schema.py
index d9b86884..086560a7 100644
--- a/graphene/types/schema.py
+++ b/graphene/types/schema.py
@@ -13,7 +13,6 @@ from graphql.utils.schema_printer import print_schema
 from .definitions import GrapheneGraphQLType
 from .objecttype import ObjectType
 from .typemap import TypeMap, is_graphene_type
-from ..utils.comparison_helper import raise_assertion_if_not
 
 
 def assert_valid_root_type(_type):
@@ -21,11 +20,8 @@ def assert_valid_root_type(_type):
         return
     is_graphene_objecttype = inspect.isclass(_type) and issubclass(_type, ObjectType)
     is_graphql_objecttype = isinstance(_type, GraphQLObjectType)
-    raise_assertion_if_not(
-        condition=is_graphene_objecttype or is_graphql_objecttype,
-        message="Type {} is not a valid ObjectType.".format(_type),
-    )
-
+    if not is_graphene_objecttype or is_graphql_objecttype:
+        raise AssertionError("Type {} is not a valid ObjectType.".format(_type))
 
 class Schema(GraphQLSchema):
     """
@@ -55,12 +51,10 @@ class Schema(GraphQLSchema):
         if directives is None:
             directives = [GraphQLIncludeDirective, GraphQLSkipDirective]
 
-        raise_assertion_if_not(
-            condition=all(isinstance(d, GraphQLDirective) for d in directives),
-            message="Schema directives must be List[GraphQLDirective] if provided but got: {}.".format(
+        if not all(isinstance(d, GraphQLDirective) for d in directives):
+            raise AssertionError("Schema directives must be List[GraphQLDirective] if provided but got: {}.".format(
                 directives
-            ),
-        )
+            ))
         self._directives = directives
         self.build_typemap()
 
diff --git a/graphene/types/structures.py b/graphene/types/structures.py
index 0647c5eb..7b503bab 100644
--- a/graphene/types/structures.py
+++ b/graphene/types/structures.py
@@ -1,6 +1,5 @@
 from .unmountedtype import UnmountedType
 from .utils import get_type
-from ..utils.comparison_helper import raise_assertion_if_not
 
 
 class Structure(UnmountedType):
@@ -68,12 +67,10 @@ class NonNull(Structure):
 
     def __init__(self, *args, **kwargs):
         super(NonNull, self).__init__(*args, **kwargs)
-        raise_assertion_if_not(
-            condition=not isinstance(self._of_type, NonNull),
-            message="Can only create NonNull of a Nullable GraphQLType but got: {}.".format(
+        if isinstance(self._of_type, NonNull):
+            raise AssertionError("Can only create NonNull of a Nullable GraphQLType but got: {}.".format(
                 self._of_type
-            ),
-        )
+            ))
 
     def __str__(self):
         return "{}!".format(self.of_type)
diff --git a/graphene/types/typemap.py b/graphene/types/typemap.py
index 93ea8ed9..1001a371 100644
--- a/graphene/types/typemap.py
+++ b/graphene/types/typemap.py
@@ -40,7 +40,6 @@ from .scalars import ID, Boolean, Float, Int, Scalar, String
 from .structures import List, NonNull
 from .union import Union
 from .utils import get_field_as
-from ..utils.comparison_helper import raise_assertion_if_not
 
 
 def is_graphene_type(_type):
@@ -61,16 +60,13 @@ def resolve_type(resolve_type_func, map, type_name, root, info):
 
     if inspect.isclass(_type) and issubclass(_type, ObjectType):
         graphql_type = map.get(_type._meta.name)
-        raise_assertion_if_not(
-            condition=graphql_type,
-            message="Can't find type {} in schema".format(_type._meta.name),
-        )
-        raise_assertion_if_not(
-            condition=graphql_type.graphene_type is _type,
-            message="The type {} does not match with the associated graphene type {}.".format(
+        if not graphql_type:
+            raise AssertionError("Can't find type {} in schema".format(_type._meta.name))
+
+        if not graphql_type.graphene_type is _type:
+            raise AssertionError("The type {} does not match with the associated graphene type {}.".format(
                 _type, graphql_type.graphene_type
-            ),
-        )
+            ))
         return graphql_type
 
     return _type
@@ -101,12 +97,10 @@ class TypeMap(GraphQLTypeMap):
         if type._meta.name in map:
             _type = map[type._meta.name]
             if isinstance(_type, GrapheneGraphQLType):
-                raise_assertion_if_not(
-                    condition=_type.graphene_type is type,
-                    message="Found different types with the same name in the schema: {}, {}.".format(
+                if not _type.graphene_type is type:
+                    raise AssertionError("Found different types with the same name in the schema: {}, {}.".format(
                         _type.graphene_type, type
-                    ),
-                )
+                    ))
             return map
 
         if issubclass(type, ObjectType):
@@ -183,12 +177,10 @@ class TypeMap(GraphQLTypeMap):
         if type._meta.name in map:
             _type = map[type._meta.name]
             if isinstance(_type, GrapheneGraphQLType):
-                raise_assertion_if_not(
-                    condition=_type.graphene_type is type,
-                    message="Found different types with the same name in the schema: {}, {}.".format(
+                if not _type.graphene_type is type:
+                    raise AssertionError("Found different types with the same name in the schema: {}, {}.".format(
                         _type.graphene_type, type
-                    ),
-                )
+                    ))
             return _type
 
         def interfaces():
@@ -196,9 +188,8 @@ class TypeMap(GraphQLTypeMap):
             for interface in type._meta.interfaces:
                 self.graphene_reducer(map, interface)
                 internal_type = map[interface._meta.name]
-                raise_assertion_if_not(
-                    condition=internal_type.graphene_type is interface
-                )
+                if not internal_type.graphene_type is interface:
+                    raise AssertionError
                 interfaces.append(internal_type)
             return interfaces
 
@@ -222,12 +213,10 @@ class TypeMap(GraphQLTypeMap):
         if type._meta.name in map:
             _type = map[type._meta.name]
             if isinstance(_type, GrapheneInterfaceType):
-                raise_assertion_if_not(
-                    condition=_type.graphene_type is type,
-                    message="Found different types with the same name in the schema: {}, {}.".format(
+                if not _type.graphene_type is type:
+                    raise AssertionError("Found different types with the same name in the schema: {}, {}.".format(
                         _type.graphene_type, type
-                    ),
-                )
+                    ))
             return _type
 
         _resolve_type = None
@@ -266,9 +255,8 @@ class TypeMap(GraphQLTypeMap):
             for objecttype in type._meta.types:
                 self.graphene_reducer(map, objecttype)
                 internal_type = map[objecttype._meta.name]
-                raise_assertion_if_not(
-                    condition=internal_type.graphene_type is objecttype
-                )
+                if not internal_type.graphene_type is objecttype:
+                    raise AssertionError
                 union_types.append(internal_type)
             return union_types
 
diff --git a/graphene/types/union.py b/graphene/types/union.py
index a4f8d486..9e8f19e4 100644
--- a/graphene/types/union.py
+++ b/graphene/types/union.py
@@ -1,6 +1,5 @@
 from .base import BaseOptions, BaseType
 from .unmountedtype import UnmountedType
-from ..utils.comparison_helper import raise_assertion_if_not
 
 # For static type checking with Mypy
 MYPY = False
@@ -24,10 +23,8 @@ class Union(UnmountedType, BaseType):
 
     @classmethod
     def __init_subclass_with_meta__(cls, types=None, **options):
-        raise_assertion_if_not(
-            condition=isinstance(types, (list, tuple)) and len(types) > 0,
-            message="Must provide types for Union {name}.".format(name=cls.__name__),
-        )
+        if not isinstance(types, (list, tuple)) and len(types) > 0:
+            raise AssertionError("Must provide types for Union {name}.".format(name=cls.__name__))
         _meta = UnionOptions(cls)
         _meta.types = types
         super(Union, cls).__init_subclass_with_meta__(_meta=_meta, **options)
diff --git a/graphene/types/uuid.py b/graphene/types/uuid.py
index 4b40aa40..84089a2d 100644
--- a/graphene/types/uuid.py
+++ b/graphene/types/uuid.py
@@ -5,7 +5,6 @@ from uuid import UUID as _UUID
 from graphql.language import ast
 
 from .scalars import Scalar
-from ..utils.comparison_helper import raise_assertion_if_not
 
 
 class UUID(Scalar):
@@ -15,10 +14,8 @@ class UUID(Scalar):
     def serialize(uuid):
         if isinstance(uuid, str):
             uuid = _UUID(uuid)
-        raise_assertion_if_not(
-            condition=isinstance(uuid, _UUID),
-            message="Expected UUID instance, received {}".format(uuid),
-        )
+        if not isinstance(uuid, _UUID):
+            raise AssertionError("Expected UUID instance, received {}".format(uuid))
         return str(uuid)
 
     @staticmethod
diff --git a/graphene/utils/annotate.py b/graphene/utils/annotate.py
index d620356c..07173dcc 100644
--- a/graphene/utils/annotate.py
+++ b/graphene/utils/annotate.py
@@ -2,7 +2,6 @@ import six
 
 from ..pyutils.compat import func_name, signature
 from .deprecated import warn_deprecation
-from .comparison_helper import raise_assertion_if_not
 
 
 def annotate(_func=None, _trigger_warning=True, **annotations):
@@ -23,12 +22,10 @@ def annotate(_func=None, _trigger_warning=True, **annotations):
 
     # We make sure the annotations are valid
     for key, value in annotations.items():
-        raise_assertion_if_not(
-            condition=key in func_signature.parameters,
-            message='The key {key} is not a function parameter in the function "{func_name}".'.format(
+        if not key in func_signature.parameters:
+            raise AssertionError('The key {key} is not a function parameter in the function "{func_name}".'.format(
                 key=key, func_name=func_name(_func)
-            ),
-        )
+            ))
 
     func_annotations = getattr(_func, "__annotations__", None)
     if func_annotations is None:
diff --git a/graphene/utils/comparison_helper.py b/graphene/utils/comparison_helper.py
deleted file mode 100644
index 477382e6..00000000
--- a/graphene/utils/comparison_helper.py
+++ /dev/null
@@ -1,3 +0,0 @@
-def raise_assertion_if_not(condition=None, message=None):
-    if not condition:
-        raise AssertionError(message)
diff --git a/graphene/utils/subclass_with_meta.py b/graphene/utils/subclass_with_meta.py
index 739e2147..eb10d594 100644
--- a/graphene/utils/subclass_with_meta.py
+++ b/graphene/utils/subclass_with_meta.py
@@ -4,7 +4,6 @@ import six
 
 from ..pyutils.init_subclass import InitSubclassMeta
 from .props import props
-from .comparison_helper import raise_assertion_if_not
 
 
 class SubclassWithMeta_Meta(InitSubclassMeta):
@@ -43,13 +42,11 @@ class SubclassWithMeta(six.with_metaclass(SubclassWithMeta_Meta)):
 
         abstract = options.pop("abstract", False)
         if abstract:
-            raise_assertion_if_not(
-                condition=not options,
-                message="Abstract types can only contain the abstract attribute. "
+            if options:
+                raise AssertionError("Abstract types can only contain the abstract attribute. "
                 "Received: abstract, {option_keys}".format(
                     option_keys=", ".join(options.keys())
-                ),
-            )
+                ))
         else:
             super_class = super(cls, cls)
             if hasattr(super_class, "__init_subclass_with_meta__"):