From 11a3fe901a606d3bbb2bcf6cec14a54b77372e92 Mon Sep 17 00:00:00 2001 From: Kacppian Date: Thu, 12 Jul 2018 19:25:25 +0530 Subject: [PATCH] DRY-ed up --- graphene/pyutils/version.py | 14 +++-- graphene/relay/connection.py | 31 ++++++----- graphene/relay/mutation.py | 4 +- graphene/relay/node.py | 19 ++++--- graphene/types/argument.py | 10 ++-- graphene/types/base.py | 8 ++- graphene/types/datetime.py | 23 +++++--- graphene/types/dynamic.py | 10 ++-- graphene/types/field.py | 29 +++++----- graphene/types/mountedtype.py | 9 +-- graphene/types/objecttype.py | 20 ++++--- graphene/types/resolver.py | 9 ++- graphene/types/schema.py | 41 +++++++------- graphene/types/typemap.py | 83 ++++++++++++++-------------- graphene/types/union.py | 11 ++-- graphene/types/uuid.py | 8 ++- graphene/utils/annotate.py | 13 +++-- graphene/utils/comparison_helper.py | 3 + graphene/utils/subclass_with_meta.py | 13 ++--- 19 files changed, 201 insertions(+), 157 deletions(-) create mode 100644 graphene/utils/comparison_helper.py diff --git a/graphene/pyutils/version.py b/graphene/pyutils/version.py index ab177e12..111e2bc6 100644 --- a/graphene/pyutils/version.py +++ b/graphene/pyutils/version.py @@ -3,6 +3,7 @@ from __future__ import unicode_literals import datetime import os import subprocess +from .comparison_helper import raise_assertion_if_true def get_version(version=None): @@ -44,11 +45,14 @@ def get_complete_version(version=None): if version is None: from graphene import VERSION as version else: - if len(version) is not 5: - raise AssertionError("Version needs to be 5") - if version[3] not in ("alpha", "beta", "rc", "final"): - raise AssertionError("Release version is unkown") - + raise_assertion_if_true( + condition=len(version) is not 5, + message="Version needs to be 5" + ) + raise_assertion_if_true( + condition=version[3] not in ("alpha", "beta", "rc", "final"), + message="Release version is unkown" + ) return version diff --git a/graphene/relay/connection.py b/graphene/relay/connection.py index 3f58fdbf..9993fab8 100644 --- a/graphene/relay/connection.py +++ b/graphene/relay/connection.py @@ -9,6 +9,7 @@ from ..types import Boolean, Enum, Int, Interface, List, NonNull, Scalar, String from ..types.field import Field from ..types.objecttype import ObjectType, ObjectTypeOptions from .node import is_node +from ..utils.comparison_helper import raise_assertion_if_true class PageInfo(ObjectType): @@ -46,16 +47,20 @@ class Connection(ObjectType): @classmethod def __init_subclass_with_meta__(cls, node=None, name=None, **options): _meta = ConnectionOptions(cls) - if not node: - raise AssertionError( - "You have to provide a node in {}.Meta".format(cls.__name__) + + error_message = "You have to provide a node in {}.Meta".format(cls.__name__) + raise_assertion_if_true( + condition=not node, + message=error_message ) - if not issubclass(node, (Scalar, Enum, ObjectType, Interface, Union, NonNull)): - raise AssertionError( - 'Received incompatible node "{}" for Connection {}.'.format( - node, cls.__name__ - ) + error_message = 'Received incompatible node "{}" for Connection {}.'.format( + node, cls.__name__ + ) + condition = not issubclass(node, (Scalar, Enum, ObjectType, Interface, Union, NonNull)) + raise_assertion_if_true( + condition=condition, + message=error_message ) base_name = re.sub("Connection$", "", name or cls.__name__) or node._meta.name @@ -112,11 +117,11 @@ class IterableConnectionField(Field): "Read more: https://github.com/graphql-python/graphene/blob/v2.0.0/UPGRADE-v2.0.md#node-connections" ) - if not issubclass(connection_type, Connection): - raise AssertionError( - '{} type have to be a subclass of Connection. Received "{}".'.format( - self.__class__.__name__, connection_type - ) + error_message = '{} type have to be a subclass of Connection. Received "{}".' + .format(self.__class__.__name__, connection_type) + raise_assertion_if_true( + condition= not issubclass(connection_type, Connection), + message=error_message ) return type diff --git a/graphene/relay/mutation.py b/graphene/relay/mutation.py index 211ee44f..e1734b00 100644 --- a/graphene/relay/mutation.py +++ b/graphene/relay/mutation.py @@ -5,6 +5,7 @@ from promise import Promise, is_thenable from ..types import Field, InputObjectType, String from ..types.mutation import Mutation +from ..utils.comparison_helper import raise_assertion_if_true class ClientIDMutation(Mutation): @@ -18,8 +19,7 @@ class ClientIDMutation(Mutation): input_class = getattr(cls, "Input", None) base_name = re.sub("Payload$", "", name or cls.__name__) - if output: - raise AssertionError("Can't specify any output") + raise_assertion_if_true(condition=output, message="Can't specify any output") if arguments: raise AssertionError("Can't specify any arguments") diff --git a/graphene/relay/node.py b/graphene/relay/node.py index 44020ae3..74cb2fa7 100644 --- a/graphene/relay/node.py +++ b/graphene/relay/node.py @@ -7,6 +7,9 @@ from graphql_relay import from_global_id, to_global_id from ..types import ID, Field, Interface, ObjectType from ..types.interface import InterfaceOptions from ..types.utils import get_type +from ..utils.comparison_helper import raise_assertion_if_true + + def is_node(objecttype): @@ -49,8 +52,10 @@ class GlobalID(Field): class NodeField(Field): def __init__(self, node, type=False, deprecation_reason=None, name=None, **kwargs): - if not issubclass(node, Node): - raise AssertionError("NodeField can only operate in Nodes") + raise_assertion_if_true( + condition= not issubclass(node, Node), + message="NodeField can only operate in Nodes" + ) self.node_type = node self.field_type = type @@ -98,12 +103,10 @@ class Node(AbstractNode): except Exception: return None - if only_type: - if graphene_type != only_type: - raise AssertionError( - "Must receive a {} id.".format(only_type._meta.name) - ) - + raise_assertion_if_true( + condition=only_type and (graphene_type is not only_type), + message="Must receive a {} id.".format(only_type._meta.name) + ) # We make sure the ObjectType implements the "Node" interface if cls not in graphene_type._meta.interfaces: return None diff --git a/graphene/types/argument.py b/graphene/types/argument.py index 326e173d..cf296feb 100644 --- a/graphene/types/argument.py +++ b/graphene/types/argument.py @@ -5,7 +5,7 @@ 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_true class Argument(MountedType): def __init__( @@ -73,10 +73,10 @@ def to_arguments(args, extra_args=None): raise ValueError('Unknown argument "{}".'.format(default_name)) arg_name = default_name or arg.name - if arg_name in arguments: - raise AssertionError( - 'More than one Argument have same name "{}".'.format(arg_name) - ) + raise_assertion_if_true( + condition=arg_name in arguments, + message='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 1b4d4034..462e815e 100644 --- a/graphene/types/base.py +++ b/graphene/types/base.py @@ -1,6 +1,6 @@ from ..utils.subclass_with_meta import SubclassWithMeta from ..utils.trim_docstring import trim_docstring - +from ..utils.comparison_helper import raise_assertion_if_true class BaseOptions(object): name = None # type: str @@ -31,8 +31,10 @@ class BaseType(SubclassWithMeta): @classmethod def __init_subclass_with_meta__(cls, name=None, description=None, _meta=None): - if "_meta" in cls.__dict__: - raise AssertionError("Can't assign meta directly") + raise_assertion_if_true( + condition="_meta" in cls.__dict__, + message="Can't assign meta directly" + ) if not _meta: return _meta.name = name or cls.__name__ diff --git a/graphene/types/datetime.py b/graphene/types/datetime.py index 3aa38c98..4fea4f5d 100644 --- a/graphene/types/datetime.py +++ b/graphene/types/datetime.py @@ -6,7 +6,7 @@ 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_true class Date(Scalar): """ @@ -19,8 +19,10 @@ class Date(Scalar): def serialize(date): if isinstance(date, datetime.datetime): date = date.date() - if not isinstance(date, datetime.date): - raise AssertionError('Received not compatible date "{}"'.format(repr(date))) + raise_assertion_if_true( + condition=not isinstance(date, datetime.date), + message='Received not compatible date "{}"'.format(repr(date)) + ) return date.isoformat() @classmethod @@ -45,10 +47,11 @@ class DateTime(Scalar): @staticmethod def serialize(dt): - if not isinstance(dt, (datetime.datetime, datetime.date)): - raise AssertionError( - 'Received not compatible datetime "{}"'.format(repr(dt)) - ) + + raise_assertion_if_true( + condition=not isinstance(dt, (datetime.datetime, datetime.date)), + message='Received not compatible datetime "{}"'.format(repr(dt)) + ) return dt.isoformat() @classmethod @@ -73,8 +76,10 @@ class Time(Scalar): @staticmethod def serialize(time): - if not isinstance(time, datetime.time): - raise AssertionError('Received not compatible time "{}"'.format(repr(time))) + raise_assertion_if_true( + condition= not isinstance(time, datetime.time), + message='Received not compatible time "{}"'.format(repr(time)) + ) return time.isoformat() @classmethod diff --git a/graphene/types/dynamic.py b/graphene/types/dynamic.py index d7747644..b7248105 100644 --- a/graphene/types/dynamic.py +++ b/graphene/types/dynamic.py @@ -3,6 +3,8 @@ from functools import partial from .mountedtype import MountedType +from ..utils.comparison_helper import raise_assertion_if_true + class Dynamic(MountedType): """ @@ -12,10 +14,10 @@ class Dynamic(MountedType): def __init__(self, type, with_schema=False, _creation_counter=None): super(Dynamic, self).__init__(_creation_counter=_creation_counter) - if not (inspect.isfunction(type) or isinstance(type, partial)): - raise AssertionError( - "type is expected to be a function or an instance of partial" - ) + raise_assertion_if_true( + condition=not (inspect.isfunction(type) or isinstance(type, partial)), + message="type is expected to be a function or an instance of partial" + ) self.type = type self.with_schema = with_schema diff --git a/graphene/types/field.py b/graphene/types/field.py index a42d131a..8112709e 100644 --- a/graphene/types/field.py +++ b/graphene/types/field.py @@ -7,6 +7,7 @@ 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_true base_type = type @@ -35,20 +36,20 @@ class Field(MountedType): ): super(Field, self).__init__(_creation_counter=_creation_counter) - if args and not isinstance(args, Mapping): - raise AssertionError( - 'Arguments in a field have to be a mapping, received "{}".'.format(args) - ) - if source and resolver: - raise AssertionError( - "A Field cannot have a source and a resolver in at the same time." - ) - if callable(default_value): - raise AssertionError( - 'The default value can not be a function but received "{}".'.format( - base_type(default_value) - ) - ) + raise_assertion_if_true( + condition=args and not isinstance(args, Mapping), + message='Arguments in a field have to be a mapping, received "{}".'.format(args) + ) + + raise_assertion_if_true( + condition=source and resolver, + message="A Field cannot have a source and a resolver in at the same time." + ) + + raise_assertion_if_true( + condition=callable(default_value), + message='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 fc4efb85..385c4c5b 100644 --- a/graphene/types/mountedtype.py +++ b/graphene/types/mountedtype.py @@ -1,6 +1,7 @@ from ..utils.orderedtype import OrderedType from .unmountedtype import UnmountedType +from ..utils.comparison_helper import raise_assertion_if_true class MountedType(OrderedType): @classmethod @@ -8,10 +9,10 @@ class MountedType(OrderedType): """ Mount the UnmountedType instance """ - if not isinstance(unmounted, UnmountedType): - raise AssertionError( - "{} can't mount {}".format(cls.__name__, repr(unmounted)) - ) + raise_assertion_if_true( + condition=not isinstance(unmounted, UnmountedType), + message="{} can't mount {}".format(cls.__name__, repr(unmounted) + ) return cls( unmounted.get_type(), diff --git a/graphene/types/objecttype.py b/graphene/types/objecttype.py index 2be97358..2a9f7871 100644 --- a/graphene/types/objecttype.py +++ b/graphene/types/objecttype.py @@ -5,6 +5,8 @@ from .field import Field from .interface import Interface from .utils import yank_fields_from_attrs +from ..utils.comparison_helper import raise_assertion_if_true + # For static type checking with Mypy MYPY = False if MYPY: @@ -47,15 +49,15 @@ class ObjectType(BaseType): for base in reversed(cls.__mro__): fields.update(yank_fields_from_attrs(base.__dict__, _as=Field)) - 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__ - ) - ) + error_message = """ + {name}.Meta.possible_types will cause type collision with {name}.is_type_of. + Please use one or other. + """.format(name=cls.__name__) + + raise_assertion_if_true( + condition=possible_types and cls.is_type_of, + message=error_message + ) if _meta.fields: _meta.fields.update(fields) diff --git a/graphene/types/resolver.py b/graphene/types/resolver.py index d9151b2a..ab21d379 100644 --- a/graphene/types/resolver.py +++ b/graphene/types/resolver.py @@ -1,3 +1,5 @@ +from ..utils.comparison_helper import raise_assertion_if_true + def attr_resolver(attname, default_value, root, info, **args): return getattr(root, attname, default_value) @@ -11,8 +13,11 @@ default_resolver = attr_resolver def set_default_resolver(resolver): global default_resolver - if not callable(resolver): - raise AssertionError("Received non-callable resolver.") + + raise_assertion_if_true( + condition=not callable(resolver), + message="Received non-callable resolver." + ) default_resolver = resolver diff --git a/graphene/types/schema.py b/graphene/types/schema.py index 9250f86d..b3886725 100644 --- a/graphene/types/schema.py +++ b/graphene/types/schema.py @@ -13,15 +13,17 @@ 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_true def assert_valid_root_type(_type): if _type is None: return is_graphene_objecttype = inspect.isclass(_type) and issubclass(_type, ObjectType) is_graphql_objecttype = isinstance(_type, GraphQLObjectType) - if not (is_graphene_objecttype or is_graphql_objecttype): - raise AssertionError("Type {} is not a valid ObjectType.".format(_type)) + raise_assertion_if_true( + condition=not (is_graphene_objecttype or is_graphql_objecttype), + message="Type {} is not a valid ObjectType.".format(_type) + ) class Schema(GraphQLSchema): @@ -52,12 +54,10 @@ class Schema(GraphQLSchema): if directives is None: directives = [GraphQLIncludeDirective, GraphQLSkipDirective] - if not all(isinstance(d, GraphQLDirective) for d in directives): - raise AssertionError( - "Schema directives must be List[GraphQLDirective] if provided but got: {}.".format( - directives - ) - ) + raise_assertion_if_true( + condition=not all(isinstance(d, GraphQLDirective) for d in directives), + message="Schema directives must be List[GraphQLDirective] if provided but got: {}.".format(directives) + ) self._directives = directives self.build_typemap() @@ -91,16 +91,19 @@ class Schema(GraphQLSchema): return _type if is_graphene_type(_type): graphql_type = self.get_type(_type._meta.name) - if not graphql_type: - raise AssertionError( - "Type {} not found in this schema.".format(_type._meta.name) - ) - if graphql_type.graphene_type != _type: - raise AssertionError( - "The type {} does not match with the associated graphene type {}.".format( - _type, graphql_type.graphene_type - ) - ) + + raise_assertion_if_true( + condition=not graphql_type, + message="Type {} not found in this schema.".format(_type._meta.name) + ) + + error_message = "The type {} does not match with the associated graphene type {}." + .format(_type, graphql_type.graphene_type) + raise_assertion_if_true( + condition=graphql_type.graphene_type is not _type, + message=error_message + ) + return graphql_type raise Exception("{} is not a valid GraphQL type.".format(_type)) diff --git a/graphene/types/typemap.py b/graphene/types/typemap.py index f34cd50e..c83b3d54 100644 --- a/graphene/types/typemap.py +++ b/graphene/types/typemap.py @@ -40,6 +40,7 @@ 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_true def is_graphene_type(_type): @@ -60,16 +61,18 @@ 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) - if not graphql_type: - raise AssertionError( - "Can't find type {} in schema".format(_type._meta.name) - ) - if graphql_type.graphene_type != _type: - raise AssertionError( - "The type {} does not match with the associated graphene type {}.".format( - _type, graphql_type.graphene_type - ) - ) + raise_assertion_if_true( + condition=not graphql_type, + message="Can't find type {} in schema".format(_type._meta.name) + ) + + error_message = "The type {} does not match with the associated graphene type {}." + .format( _type, graphql_type.graphene_type) + raise_assertion_if_true( + condition=graphql_type.graphene_type is not _type, + message=error_message + ) + return graphql_type return _type @@ -100,12 +103,12 @@ class TypeMap(GraphQLTypeMap): if type._meta.name in map: _type = map[type._meta.name] if isinstance(_type, GrapheneGraphQLType): - if _type.graphene_type is not type: - raise AssertionError( - "Found different types with the same name in the schema: {}, {}.".format( - _type.graphene_type, type - ) - ) + error_message = "Found different types with the same name in the schema: {}, {}." + .format(_type.graphene_type, type) + raise_assertion_if_true( + condition=_type.graphene_type is not type, + message=error_message + ) return map if issubclass(type, ObjectType): @@ -182,12 +185,12 @@ class TypeMap(GraphQLTypeMap): if type._meta.name in map: _type = map[type._meta.name] if isinstance(_type, GrapheneGraphQLType): - if _type.graphene_type != type: - raise AssertionError( - "Found different types with the same name in the schema: {}, {}.".format( - _type.graphene_type, type - ) - ) + error_message = "Found different types with the same name in the schema: {}, {}." + .format(_type.graphene_type, type) + raise_assertion_if_true( + condition=_type.graphene_type is not type, + message=error_message + ) return _type def interfaces(): @@ -195,12 +198,12 @@ class TypeMap(GraphQLTypeMap): for interface in type._meta.interfaces: self.graphene_reducer(map, interface) internal_type = map[interface._meta.name] - if internal_type.graphene_type != interface: - raise AssertionError( - "Found different types with the same name in the schema: {}, {}.".format( - internal_type.graphene_type, interface - ) - ) + error_message = "Found different types with the same name in the schema: {}, {}." + .format(internal_type.graphene_type, interface) + raise_assertion_if_true( + condition=internal_type.graphene_type is not interface, + message=error_message + ) interfaces.append(internal_type) return interfaces @@ -224,12 +227,12 @@ class TypeMap(GraphQLTypeMap): if type._meta.name in map: _type = map[type._meta.name] if isinstance(_type, GrapheneInterfaceType): - if _type.graphene_type != type: - raise AssertionError( - "Found different types with the same name in the schema: {}, {}.".format( - _type.graphene_type, type - ) - ) + error_message = "Found different types with the same name in the schema: {}, {}." + .format(_type.graphene_type, type) + raise_assertion_if_true( + condition= _type.graphene_type is not type, + message=error_message + ) return _type _resolve_type = None @@ -268,12 +271,12 @@ class TypeMap(GraphQLTypeMap): for objecttype in type._meta.types: self.graphene_reducer(map, objecttype) internal_type = map[objecttype._meta.name] - if internal_type.graphene_type != objecttype: - raise AssertionError( - "Found different types with the same name in the schema: {}, {}.".format( - internal_type.graphene_type, objecttype - ) - ) + error_message = "Found different types with the same name in the schema: {}, {}." + .format(internal_type.graphene_type, objecttype) + raise_assertion_if_true( + condition=internal_type.graphene_type is not objecttype, + message=error_message + ) union_types.append(internal_type) return union_types diff --git a/graphene/types/union.py b/graphene/types/union.py index 1c14fd71..1c0459ef 100644 --- a/graphene/types/union.py +++ b/graphene/types/union.py @@ -1,6 +1,8 @@ from .base import BaseOptions, BaseType from .unmountedtype import UnmountedType +from ..utils.comparison_helper import raise_assertion_if_true + # For static type checking with Mypy MYPY = False if MYPY: @@ -23,10 +25,11 @@ class Union(UnmountedType, BaseType): @classmethod def __init_subclass_with_meta__(cls, types=None, **options): - if not (isinstance(types, (list, tuple)) and len(types) > 0): - raise AssertionError( - "Must provide types for Union {name}.".format(name=cls.__name__) - ) + + raise_assertion_if_true( + condition=not (isinstance(types, (list, tuple)) and len(types) > 0, + message="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 84089a2d..7b944b8a 100644 --- a/graphene/types/uuid.py +++ b/graphene/types/uuid.py @@ -5,7 +5,7 @@ from uuid import UUID as _UUID from graphql.language import ast from .scalars import Scalar - +from ..utils.comparison_helper import raise_assertion_if_true class UUID(Scalar): """UUID""" @@ -14,8 +14,10 @@ class UUID(Scalar): def serialize(uuid): if isinstance(uuid, str): uuid = _UUID(uuid) - if not isinstance(uuid, _UUID): - raise AssertionError("Expected UUID instance, received {}".format(uuid)) + raise_assertion_if_true( + condition=not isinstance(uuid, _UUID), + message="Expected UUID instance, received {}".format(uuid) + ) return str(uuid) @staticmethod diff --git a/graphene/utils/annotate.py b/graphene/utils/annotate.py index 18dcd881..1b6eaa95 100644 --- a/graphene/utils/annotate.py +++ b/graphene/utils/annotate.py @@ -2,6 +2,7 @@ import six from ..pyutils.compat import func_name, signature from .deprecated import warn_deprecation +from .comparison_helper import raise_assertion_if_true def annotate(_func=None, _trigger_warning=True, **annotations): @@ -22,11 +23,13 @@ def annotate(_func=None, _trigger_warning=True, **annotations): # We make sure the annotations are valid for key, value in annotations.items(): - if func_signature.parameters.get(key, None) is None: - raise AssertionError( - 'The key {key} is not a function parameter in the function "{func_name}".'.format( - key=key, func_name=func_name(_func) - ) + func_param = func_signature.parameters.get(key, None) + assertion_message = 'The key {key} is not a function parameter in the function "{func_name}".' + .format(key=key, func_name=func_name(_func) + + raise_assertion_if_true( + condition=func_param is None, + message=assertion_message ) func_annotations = getattr(_func, "__annotations__", None) diff --git a/graphene/utils/comparison_helper.py b/graphene/utils/comparison_helper.py new file mode 100644 index 00000000..14e8ddd2 --- /dev/null +++ b/graphene/utils/comparison_helper.py @@ -0,0 +1,3 @@ +def raise_assertion_if_true(condition=None, message=None): + if condition: + raise AssertionError(message) \ No newline at end of file diff --git a/graphene/utils/subclass_with_meta.py b/graphene/utils/subclass_with_meta.py index 2889862f..56b00a3f 100644 --- a/graphene/utils/subclass_with_meta.py +++ b/graphene/utils/subclass_with_meta.py @@ -41,16 +41,13 @@ class SubclassWithMeta(six.with_metaclass(SubclassWithMeta_Meta)): options = dict(meta_options, **_meta_props) abstract = options.pop("abstract", False) - if abstract: - if options: - raise AssertionError( - """ + error_message = """ Abstract types can only contain the abstract attribute. Received: abstract, {option_keys} - """.format( - option_keys=", ".join(options.keys()) - ) - ) + """.format(option_keys=", ".join(options.keys()) + + raise_assertion_if_true(condition=options and abstract, message=error_message) + else: super_class = super(cls, cls) if hasattr(super_class, "__init_subclass_with_meta__"):