graphql-python/graphene
1
1
Fork 0
mirror of https://github.com/graphql-python/graphene.git synced 2025-07-18 03:52:24 +03:00
Code Issues Packages Projects Releases Wiki Activity

Updated all str.format(…) to f-strings

Browse Source 
This revamps the PR #984
This commit is contained in:
Syrus 2020-03-14 17:23:38 -07:00
parent 14183012a8
commit a22b09c621
29 changed files with 109 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
UPGRADE-v2.0.md
View File

@ -377,10 +377,7 @@ class Base(ObjectType):
id = ID()
def resolve_id(root, info):
return "{type}_{id}".format(
type=root.__class__.__name__,
id=root.id
)
return f"{root.__class__.__name__}_{root.id}"
```
### UUID Scalar

9
docs/execution/middleware.rst
View File

@ -55,12 +55,9 @@ logs the time it takes to resolve each field
def timing_middleware(next, root, info, **args):
start = timer()
return_value = next(root, info, **args)
duration = timer() - start
logger.debug("{parent_type}.{field_name}: {duration} ms".format(
parent_type=root._meta.name if root and hasattr(root, '_meta') else '',
field_name=info.field_name,
duration=round(duration * 1000, 2)
))
duration = round((timer() - start) * 1000, 2)
parent_type_name = root._meta.name if root and hasattr(root, '_meta') else ''
logger.debug(f"{parent_type_name}.{info.field_name}: {duration} ms")
return return_value

2
docs/relay/nodes.rst
View File

@ -52,7 +52,7 @@ Example of a custom node:
@staticmethod
def to_global_id(type, id):
return '{}:{}'.format(type, id)
return f"{type}:{id}"
@staticmethod
def get_node_from_global_id(info, global_id, only_type=None):

2
docs/types/objecttypes.rst
View File

@ -331,7 +331,7 @@ A field can use a custom resolver from outside the class:
from graphene import ObjectType, String
def resolve_full_name(person, info):
return '{} {}'.format(person.first_name, person.last_name)
return f"{person.first_name} {person.last_name}"
class Person(ObjectType):
first_name = String()

2
examples/complex_example.py
View File

@ -7,7 +7,7 @@ class GeoInput(graphene.InputObjectType):
@property
def latlng(self):
return "({},{})".format(self.lat, self.lng)
return f"({self.lat},{self.lng})"
class Address(graphene.ObjectType):

24
graphene/relay/connection.py
View File

@ -63,16 +63,14 @@ class Connection(ObjectType):
@classmethod
def __init_subclass_with_meta__(cls, node=None, name=None, **options):
_meta = ConnectionOptions(cls)
assert node, "You have to provide a node in {}.Meta".format(cls.__name__)
assert node, f"You have to provide a node in {cls.__name__}.Meta"
assert isinstance(node, NonNull) or issubclass(
node, (Scalar, Enum, ObjectType, Interface, Union, NonNull)
), ('Received incompatible node "{}" for Connection {}.').format(
node, cls.__name__
)
), (f"Received incompatible node \"{node}\" for Connection {cls.__name__}.")
base_name = re.sub("Connection$", "", name or cls.__name__) or node._meta.name
if not name:
name = "{}Connection".format(base_name)
name = f"{base_name}Connection"
edge_class = getattr(cls, "Edge", None)
_node = node
@ -82,11 +80,9 @@ class Connection(ObjectType):
cursor = String(required=True, description="A cursor for use in pagination")
class EdgeMeta:
description = "A Relay edge containing a `{}` and its cursor.".format(
base_name
)
description = f"A Relay edge containing a `{base_name}` and its cursor."
edge_name = "{}Edge".format(base_name)
edge_name = f"{base_name}Edge"
if edge_class:
edge_bases = (edge_class, EdgeBase, ObjectType)
else:
@ -142,8 +138,8 @@ class IterableConnectionField(Field):
)
assert issubclass(connection_type, Connection), (
'{} type has to be a subclass of Connection. Received "{}".'
).format(self.__class__.__name__, connection_type)
f"{self.__class__.__name__} type has to be a subclass of Connection. Received \"{connection_type}\"."
)
return type
@classmethod
@ -152,9 +148,9 @@ class IterableConnectionField(Field):
return resolved
assert isinstance(resolved, Iterable), (
"Resolved value from the connection field has to be an iterable or instance of {}. "
'Received "{}"'
).format(connection_type, resolved)
f"Resolved value from the connection field has to be an iterable or instance of {connection_type}. "
f"Received \"{resolved}\""
)
connection = connection_from_array(
resolved,
args,

12
graphene/relay/mutation.py
View File

@ -27,7 +27,7 @@ class ClientIDMutation(Mutation):
input_fields = {}
cls.Input = type(
"{}Input".format(base_name),
f"{base_name}Input",
bases,
dict(input_fields, client_mutation_id=String(name="clientMutationId")),
)
@ -39,12 +39,12 @@ class ClientIDMutation(Mutation):
mutate_and_get_payload = getattr(cls, "mutate_and_get_payload", None)
if cls.mutate and cls.mutate.__func__ == ClientIDMutation.mutate.__func__:
assert mutate_and_get_payload, (
"{name}.mutate_and_get_payload method is required"
f"{name or cls.__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)
name = f"{base_name}Payload"
super(ClientIDMutation, cls).__init_subclass_with_meta__(
output=None, arguments=arguments, name=name, **options
@ -58,9 +58,7 @@ class ClientIDMutation(Mutation):
payload.client_mutation_id = input.get("client_mutation_id")
except Exception:
raise Exception(
("Cannot set client_mutation_id in the payload object {}").format(
repr(payload)
)
f"Cannot set client_mutation_id in the payload object {repr(payload)}"
)
return payload

16
graphene/relay/node.py
View File

@ -93,33 +93,29 @@ class Node(AbstractNode):
except Exception as e:
raise Exception(
(
'Unable to parse global ID "{global_id}". '
f"Unable to parse global ID \"{global_id}\". "
'Make sure it is a base64 encoded string in the format: "TypeName:id". '
"Exception message: {exception}".format(
global_id=global_id, exception=str(e)
)
f"Exception message: {str(e)}"
)
)
graphene_type = info.schema.get_type(_type)
if graphene_type is None:
raise Exception(
'Relay Node "{_type}" not found in schema'.format(_type=_type)
f"Relay Node \"{_type}\" not found in schema"
)
graphene_type = graphene_type.graphene_type
if only_type:
assert graphene_type == only_type, ("Must receive a {} id.").format(
only_type._meta.name
assert graphene_type == only_type, (
f"Must receive a {only_type._meta.name} id."
)
# We make sure the ObjectType implements the "Node" interface
if cls not in graphene_type._meta.interfaces:
raise Exception(
'ObjectType "{_type}" does not implement the "{cls}" interface.'.format(
_type=_type, cls=cls
)
f"ObjectType \"{_type}\" does not implement the \"{cls}\" interface."
)
get_node = getattr(graphene_type, "get_node", None)

28
graphene/relay/tests/test_connection_query.py
View File

@ -135,31 +135,31 @@ async def test_respects_an_overly_large_last():
@mark.asyncio
async def test_respects_first_and_after():
await check(
'first: 2, after: "{}"'.format(cursor_for("B")), "CD", has_next_page=True
f'first: 2, after: \"{cursor_for("B")}\"', "CD", has_next_page=True
)
@mark.asyncio
async def test_respects_first_and_after_with_long_first():
await check('first: 10, after: "{}"'.format(cursor_for("B")), "CDE")
await check(f'first: 10, after: "{cursor_for("B")}"', "CDE")
@mark.asyncio
async def test_respects_last_and_before():
await check(
'last: 2, before: "{}"'.format(cursor_for("D")), "BC", has_previous_page=True
f'last: 2, before: "{cursor_for("D")}"', "BC", has_previous_page=True
)
@mark.asyncio
async def test_respects_last_and_before_with_long_last():
await check('last: 10, before: "{}"'.format(cursor_for("D")), "ABC")
await check(f'last: 10, before: "{cursor_for("D")}"', "ABC")
@mark.asyncio
async def test_respects_first_and_after_and_before_too_few():
await check(
'first: 2, after: "{}", before: "{}"'.format(cursor_for("A"), cursor_for("E")),
f'first: 2, after: "{cursor_for("A")}", before: "{cursor_for("E")}"',
"BC",
has_next_page=True,
)
@ -168,7 +168,7 @@ async def test_respects_first_and_after_and_before_too_few():
@mark.asyncio
async def test_respects_first_and_after_and_before_too_many():
await check(
'first: 4, after: "{}", before: "{}"'.format(cursor_for("A"), cursor_for("E")),
f'first: 4, after: "{cursor_for("A")}", before: "{cursor_for("E")}"',
"BCD",
)
@ -176,7 +176,7 @@ async def test_respects_first_and_after_and_before_too_many():
@mark.asyncio
async def test_respects_first_and_after_and_before_exactly_right():
await check(
'first: 3, after: "{}", before: "{}"'.format(cursor_for("A"), cursor_for("E")),
f'first: 3, after: "{cursor_for("A")}", before: "{cursor_for("E")}"',
"BCD",
)
@ -184,7 +184,7 @@ async def test_respects_first_and_after_and_before_exactly_right():
@mark.asyncio
async def test_respects_last_and_after_and_before_too_few():
await check(
'last: 2, after: "{}", before: "{}"'.format(cursor_for("A"), cursor_for("E")),
f'last: 2, after: "{cursor_for("A")}", before: "{cursor_for("E")}"',
"CD",
has_previous_page=True,
)
@ -193,7 +193,7 @@ async def test_respects_last_and_after_and_before_too_few():
@mark.asyncio
async def test_respects_last_and_after_and_before_too_many():
await check(
'last: 4, after: "{}", before: "{}"'.format(cursor_for("A"), cursor_for("E")),
f'last: 4, after: "{cursor_for("A")}", before: "{cursor_for("E")}"',
"BCD",
)
@ -201,7 +201,7 @@ async def test_respects_last_and_after_and_before_too_many():
@mark.asyncio
async def test_respects_last_and_after_and_before_exactly_right():
await check(
'last: 3, after: "{}", before: "{}"'.format(cursor_for("A"), cursor_for("E")),
f'last: 3, after: "{cursor_for("A")}", before: "{cursor_for("E")}"',
"BCD",
)
@ -219,9 +219,7 @@ async def test_returns_all_elements_if_cursors_are_invalid():
@mark.asyncio
async def test_returns_all_elements_if_cursors_are_on_the_outside():
await check(
'before: "{}" after: "{}"'.format(
base64("arrayconnection:%s" % 6), base64("arrayconnection:%s" % -1)
),
f'before: "{base64("arrayconnection:%s" % 6)}" after: "{base64("arrayconnection:%s" % -1)}"',
"ABCDE",
)
@ -229,9 +227,7 @@ async def test_returns_all_elements_if_cursors_are_on_the_outside():
@mark.asyncio
async def test_returns_no_elements_if_cursors_cross():
await check(
'before: "{}" after: "{}"'.format(
base64("arrayconnection:%s" % 2), base64("arrayconnection:%s" % 4)
),
f'before: "{base64("arrayconnection:%s" % 2)}" after: "{base64("arrayconnection:%s" % 4)}"',
"",
)

8
graphene/types/argument.py
View File

@ -94,18 +94,16 @@ def to_arguments(args, extra_args=None):
if isinstance(arg, (InputField, Field)):
raise ValueError(
"Expected {} to be Argument, but received {}. Try using Argument({}).".format(
default_name, type(arg).__name__, arg.type
)
f"Expected {default_name} to be Argument, but received {type(arg).__name__}. Try using Argument({arg.type})."
)
if not isinstance(arg, Argument):
raise ValueError('Unknown argument "{}".'.format(default_name))
raise ValueError(f'Unknown argument "{default_name}".')
arg_name = default_name or arg.name
assert (
arg_name not in arguments
), 'More than one Argument have same name "{}".'.format(arg_name)
), f'More than one Argument have same name "{arg_name}".'
arguments[arg_name] = arg
return arguments

4
graphene/types/base.py
View File

@ -20,10 +20,10 @@ class BaseOptions:
if not self._frozen:
super(BaseOptions, self).__setattr__(name, value)
else:
raise Exception("Can't modify frozen Options {}".format(self))
raise Exception(f"Can't modify frozen Options {self}")
def __repr__(self):
return "<{} name={}>".format(self.__class__.__name__, repr(self.name))
return f"<{self.__class__.__name__} name={repr(self.name)}>"
class BaseType(SubclassWithMeta):

24
graphene/types/datetime.py
View File

@ -21,14 +21,14 @@ class Date(Scalar):
if isinstance(date, datetime.datetime):
date = date.date()
if not isinstance(date, datetime.date):
raise GraphQLError("Date cannot represent value: {}".format(repr(date)))
raise GraphQLError(f"Date cannot represent value: {repr(date)}")
return date.isoformat()
@classmethod
def parse_literal(cls, node):
if not isinstance(node, StringValueNode):
raise GraphQLError(
"Date cannot represent non-string value: {}".format(print_ast(node))
f"Date cannot represent non-string value: {print_ast(node)}"
)
return cls.parse_value(node.value)
@ -38,12 +38,12 @@ class Date(Scalar):
return value
if not isinstance(value, str):
raise GraphQLError(
"Date cannot represent non-string value: {}".format(repr(value))
f"Date cannot represent non-string value: {repr(value)}"
)
try:
return parse_date(value)
except ValueError:
raise GraphQLError("Date cannot represent value: {}".format(repr(value)))
raise GraphQLError(f"Date cannot represent value: {repr(value)}")
class DateTime(Scalar):
@ -56,14 +56,14 @@ class DateTime(Scalar):
@staticmethod
def serialize(dt):
if not isinstance(dt, (datetime.datetime, datetime.date)):
raise GraphQLError("DateTime cannot represent value: {}".format(repr(dt)))
raise GraphQLError(f"DateTime cannot represent value: {repr(dt)}")
return dt.isoformat()
@classmethod
def parse_literal(cls, node):
if not isinstance(node, StringValueNode):
raise GraphQLError(
"DateTime cannot represent non-string value: {}".format(print_ast(node))
f"DateTime cannot represent non-string value: {print_ast(node)}"
)
return cls.parse_value(node.value)
@ -73,13 +73,13 @@ class DateTime(Scalar):
return value
if not isinstance(value, str):
raise GraphQLError(
"DateTime cannot represent non-string value: {}".format(repr(value))
f"DateTime cannot represent non-string value: {repr(value)}"
)
try:
return parse_datetime(value)
except ValueError:
raise GraphQLError(
"DateTime cannot represent value: {}".format(repr(value))
f"DateTime cannot represent value: {repr(value)}"
)
@ -93,14 +93,14 @@ class Time(Scalar):
@staticmethod
def serialize(time):
if not isinstance(time, datetime.time):
raise GraphQLError("Time cannot represent value: {}".format(repr(time)))
raise GraphQLError(f"Time cannot represent value: {repr(time)}")
return time.isoformat()
@classmethod
def parse_literal(cls, node):
if not isinstance(node, StringValueNode):
raise GraphQLError(
"Time cannot represent non-string value: {}".format(print_ast(node))
f"Time cannot represent non-string value: {print_ast(node)}"
)
return cls.parse_value(node.value)
@ -110,9 +110,9 @@ class Time(Scalar):
return value
if not isinstance(value, str):
raise GraphQLError(
"Time cannot represent non-string value: {}".format(repr(value))
f"Time cannot represent non-string value: {repr(value)}"
)
try:
return parse_time(value)
except ValueError:
raise GraphQLError("Time cannot represent value: {}".format(repr(value)))
raise GraphQLError(f"Time cannot represent value: {repr(value)}")

4
graphene/types/decimal.py
View File

@ -16,9 +16,7 @@ class Decimal(Scalar):
def serialize(dec):
if isinstance(dec, str):
dec = _Decimal(dec)
assert isinstance(dec, _Decimal), 'Received not compatible Decimal "{}"'.format(
repr(dec)
)
assert isinstance(dec, _Decimal), f'Received not compatible Decimal "{repr(dec)}"'
return str(dec)
@classmethod

8
graphene/types/field.py
View File

@ -76,14 +76,14 @@ class Field(MountedType):
):
super(Field, self).__init__(_creation_counter=_creation_counter)
assert not args or isinstance(args, Mapping), (
'Arguments in a field have to be a mapping, received "{}".'
).format(args)
f'Arguments in a field have to be a mapping, received "{args}".'
)
assert not (
source and resolver
), "A Field cannot have a source and a resolver in at the same time."
assert not callable(default_value), (
'The default value can not be a function but received "{}".'
).format(base_type(default_value))
f'The default value can not be a function but received "{base_type(default_value)}".'
)
if required:
type = NonNull(type)

4
graphene/types/mountedtype.py
View File

@ -8,9 +8,7 @@ class MountedType(OrderedType):
"""
Mount the UnmountedType instance
"""
assert isinstance(unmounted, UnmountedType), ("{} can't mount {}").format(
cls.__name__, repr(unmounted)
)
assert isinstance(unmounted, UnmountedType), f"{cls.__name__} can't mount {repr(unmounted)}"
return cls(
unmounted.get_type(),

8
graphene/types/mutation.py
View File

@ -82,8 +82,8 @@ class Mutation(ObjectType):
for interface in interfaces:
assert issubclass(interface, Interface), (
'All interfaces of {} must be a subclass of Interface. Received "{}".'
).format(cls.__name__, interface)
f'All interfaces of {cls.__name__} must be a subclass of Interface. Received "{interface}".'
)
fields.update(interface._meta.fields)
if not output:
@ -100,11 +100,11 @@ class Mutation(ObjectType):
if input_class:
warn_deprecation(
(
"Please use {name}.Arguments instead of {name}.Input."
f"Please use {cls.__name__}.Arguments instead of {cls.__name__}.Input."
" Input is now only used in ClientMutationID.\n"
"Read more:"
" https://github.com/graphql-python/graphene/blob/v2.0.0/UPGRADE-v2.0.md#mutation-input"
).format(name=cls.__name__)
)
)
if input_class:

8
graphene/types/objecttype.py
View File

@ -102,17 +102,17 @@ class ObjectType(BaseType):
for interface in interfaces:
assert issubclass(interface, Interface), (
'All interfaces of {} must be a subclass of Interface. Received "{}".'
).format(cls.__name__, interface)
f'All interfaces of {cls.__name__} must be a subclass of Interface. Received "{interface}".'
)
fields.update(interface._meta.fields)
for base in reversed(cls.__mro__):
fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
assert not (possible_types and cls.is_type_of), (
"{name}.Meta.possible_types will cause type collision with {name}.is_type_of. "
f"{cls.__name__}.Meta.possible_types will cause type collision with {cls.__name__}.is_type_of. "
"Please use one or other."
).format(name=cls.__name__)
)
if _meta.fields:
_meta.fields.update(fields)

27
graphene/types/schema.py
View File

@ -59,8 +59,8 @@ def assert_valid_root_type(type_):
is_graphene_objecttype = inspect.isclass(type_) and issubclass(type_, ObjectType)
is_graphql_objecttype = isinstance(type_, GraphQLObjectType)
assert is_graphene_objecttype or is_graphql_objecttype, (
"Type {} is not a valid ObjectType."
).format(type_)
f"Type {type_} is not a valid ObjectType."
)
def is_graphene_type(type_):
@ -114,7 +114,7 @@ class TypeMap(dict):
name = graphene_type._meta.name
except AttributeError:
raise TypeError(
"Expected Graphene type, but received: {}.".format(graphene_type)
f"Expected Graphene type, but received: {graphene_type}."
)
graphql_type = self.get(name)
if graphql_type:
@ -133,7 +133,7 @@ class TypeMap(dict):
graphql_type = self.construct_union(graphene_type)
else:
raise TypeError(
"Expected Graphene type, but received: {}.".format(graphene_type)
f"Expected Graphene type, but received: {graphene_type}."
)
self[name] = graphql_type
return graphql_type
@ -316,12 +316,12 @@ class TypeMap(dict):
args=args,
resolve=field.get_resolver(
self.get_resolver_for_type(
graphene_type, "resolve_{}", name, field.default_value
graphene_type, f"resolve_{name}", name, field.default_value
)
),
subscribe=field.get_resolver(
self.get_resolver_for_type(
graphene_type, "subscribe_{}", name, field.default_value
graphene_type, f"subscribe_{name}", name, field.default_value
)
),
deprecation_reason=field.deprecation_reason,
@ -331,10 +331,9 @@ class TypeMap(dict):
fields[field_name] = _field
return fields
def get_resolver_for_type(self, graphene_type, pattern, name, default_value):
def get_resolver_for_type(self, graphene_type, func_name, name, default_value):
if not issubclass(graphene_type, ObjectType):
return
func_name = pattern.format(name)
resolver = getattr(graphene_type, func_name, None)
if not resolver:
# If we don't find the resolver in the ObjectType class, then try to
@ -366,10 +365,10 @@ class TypeMap(dict):
if inspect.isclass(type_) and issubclass(type_, ObjectType):
graphql_type = self.get(type_._meta.name)
assert graphql_type, "Can't find type {} in schema".format(type_._meta.name)
assert graphql_type, f"Can't find type {type_._meta.name} in schema"
assert graphql_type.graphene_type == type_, (
"The type {} does not match with the associated graphene type {}."
).format(type_, graphql_type.graphene_type)
f"The type {type_} does not match with the associated graphene type {graphql_type.graphene_type}."
)
return graphql_type
return type_
@ -377,7 +376,7 @@ class TypeMap(dict):
def get_resolver(self, graphene_type, name, default_value):
if not issubclass(graphene_type, ObjectType):
return
resolver = getattr(graphene_type, "resolve_{}".format(name), None)
resolver = getattr(graphene_type, f"resolve_{name}", None)
if not resolver:
# If we don't find the resolver in the ObjectType class, then try to
# find it in each of the interfaces
@ -385,7 +384,7 @@ class TypeMap(dict):
for interface in graphene_type._meta.interfaces:
if name not in interface._meta.fields:
continue
interface_resolver = getattr(interface, "resolve_{}".format(name), None)
interface_resolver = getattr(interface, f"resolve_{name}", None)
if interface_resolver:
break
resolver = interface_resolver
@ -458,7 +457,7 @@ class Schema:
"""
_type = self.graphql_schema.get_type(type_name)
if _type is None:
raise AttributeError('Type "{}" not found in the Schema'.format(type_name))
raise AttributeError(f'Type "{type_name}" not found in the Schema')
if isinstance(_type, GrapheneGraphQLType):
return _type.graphene_type
return _type

12
graphene/types/structures.py
View File

@ -14,9 +14,7 @@ class Structure(UnmountedType):
cls_name = type(self).__name__
of_type_name = type(of_type).__name__
raise Exception(
"{} could not have a mounted {}() as inner type. Try with {}({}).".format(
cls_name, of_type_name, cls_name, of_type_name
)
f"{cls_name} could not have a mounted {of_type_name}() as inner type. Try with {cls_name}({of_type_name})."
)
self._of_type = of_type
@ -50,7 +48,7 @@ class List(Structure):
"""
def __str__(self):
return "[{}]".format(self.of_type)
return f"[{self.of_type}]"
def __eq__(self, other):
return isinstance(other, List) and (
@ -86,11 +84,11 @@ class NonNull(Structure):
def __init__(self, *args, **kwargs):
super(NonNull, self).__init__(*args, **kwargs)
assert not isinstance(self._of_type, NonNull), (
"Can only create NonNull of a Nullable GraphQLType but got: {}."
).format(self._of_type)
f"Can only create NonNull of a Nullable GraphQLType but got: {self._of_type}."
)
def __str__(self):
return "{}!".format(self.of_type)
return f"{self.of_type}!"
def __eq__(self, other):
return isinstance(other, NonNull) and (

4
graphene/types/tests/test_datetime.py
View File

@ -180,9 +180,7 @@ def test_time_query_variable(sample_time):
def test_bad_variables(sample_date, sample_datetime, sample_time):
def _test_bad_variables(type_, input_):
result = schema.execute(
"""query Test($input: {}){{ {}(in: $input) }}""".format(
type_, type_.lower()
),
f"""query Test($input: {type_}){{ {type_.lower()}(in: $input) }}""",
variables={"input": input_},
)
assert isinstance(result.errors, list)

2
graphene/types/tests/test_enum.py
View File

@ -15,7 +15,7 @@ def test_enum_construction():
@property
def description(self):
return "Description {}".format(self.name)
return f"Description {self.name}"
assert RGB._meta.name == "RGB"
assert RGB._meta.description == "Description"

2
graphene/types/tests/test_inputobjecttype.py
View File

@ -112,7 +112,7 @@ def test_inputobjecttype_of_input():
@property
def full_name(self):
return "{} {}".format(self.first_name, self.last_name)
return f"{self.first_name} {self.last_name}"
class Parent(InputObjectType):
child = InputField(Child)

6
graphene/types/tests/test_query.py
View File

@ -454,15 +454,15 @@ def test_query_annotated_resolvers():
info = String()
def resolve_annotated(self, info, id):
return "{}-{}".format(self, id)
return f"{self}-{id}"
def resolve_context(self, info):
assert isinstance(info.context, Context)
return "{}-{}".format(self, info.context.key)
return f"{self}-{info.context.key}"
def resolve_info(self, info):
assert isinstance(info, ResolveInfo)
return "{}-{}".format(self, info.field_name)
return f"{self}-{info.field_name}"
test_schema = Schema(Query)

2
graphene/types/tests/test_type_map.py
View File

@ -37,7 +37,7 @@ def test_enum():
@property
def description(self):
return "Description {}={}".format(self.name, self.value)
return f"Description {self.name}={self.value}"
@property
def deprecation_reason(self):

2
graphene/types/union.py
View File

@ -53,7 +53,7 @@ class Union(UnmountedType, BaseType):
def __init_subclass_with_meta__(cls, types=None, **options):
assert (
isinstance(types, (list, tuple)) and len(types) > 0
), "Must provide types for Union {name}.".format(name=cls.__name__)
), f"Must provide types for Union {cls.__name__}."
_meta = UnionOptions(cls)
_meta.types = types

2
graphene/types/unmountedtype.py
View File

@ -49,7 +49,7 @@ class UnmountedType(OrderedType):
This function is called when the UnmountedType instance
is mounted (as a Field, InputField or Argument)
"""
raise NotImplementedError("get_type not implemented in {}".format(self))
raise NotImplementedError(f"get_type not implemented in {self}")
def mount_as(self, _as):
return _as.mounted(self)

4
graphene/types/uuid.py
View File

@ -17,9 +17,7 @@ class UUID(Scalar):
if isinstance(uuid, str):
uuid = _UUID(uuid)
assert isinstance(uuid, _UUID), "Expected UUID instance, received {}".format(
uuid
)
assert isinstance(uuid, _UUID), f"Expected UUID instance, received {uuid}"
return str(uuid)
@staticmethod

12
graphene/utils/deprecated.py
View File

@ -29,13 +29,13 @@ def deprecated(reason):
def decorator(func1):
if inspect.isclass(func1):
fmt1 = "Call to deprecated class {name} ({reason})."
fmt1 = f"Call to deprecated class {func1.__name__} ({reason})."
else:
fmt1 = "Call to deprecated function {name} ({reason})."
fmt1 = f"Call to deprecated function {func1.__name__} ({reason})."
@functools.wraps(func1)
def new_func1(*args, **kwargs):
warn_deprecation(fmt1.format(name=func1.__name__, reason=reason))
warn_deprecation(fmt1)
return func1(*args, **kwargs)
return new_func1
@ -55,13 +55,13 @@ def deprecated(reason):
func2 = reason
if inspect.isclass(func2):
fmt2 = "Call to deprecated class {name}."
fmt2 = f"Call to deprecated class {func2.__name__}."
else:
fmt2 = "Call to deprecated function {name}."
fmt2 = f"Call to deprecated function {func2.__name__}."
@functools.wraps(func2)
def new_func2(*args, **kwargs):
warn_deprecation(fmt2.format(name=func2.__name__))
warn_deprecation(fmt2)
return func2(*args, **kwargs)
return new_func2

10
graphene/utils/subclass_with_meta.py
View File

@ -12,7 +12,7 @@ class SubclassWithMeta_Meta(type):
return cls.__name__
def __repr__(cls):
return "<{} meta={}>".format(cls.__name__, repr(cls._meta))
return f"<{cls.__name__} meta={repr(cls._meta)}>"
class SubclassWithMeta(metaclass=SubclassWithMeta_Meta):
@ -29,9 +29,7 @@ class SubclassWithMeta(metaclass=SubclassWithMeta_Meta):
_meta_props = props(_Meta)
else:
raise Exception(
"Meta have to be either a class or a dict. Received {}".format(
_Meta
)
f"Meta have to be either a class or a dict. Received {_Meta}"
)
delattr(cls, "Meta")
options = dict(meta_options, **_meta_props)
@ -40,8 +38,8 @@ class SubclassWithMeta(metaclass=SubclassWithMeta_Meta):
if abstract:
assert not options, (
"Abstract types can only contain the abstract attribute. "
"Received: abstract, {option_keys}"
).format(option_keys=", ".join(options))
f"Received: abstract, {', '.join(options)}"
)
else:
super_class = super(cls, cls)
if hasattr(super_class, "__init_subclass_with_meta__"):