convert type comments to annotations

Author: ewhauser

graphene_tornado/apollo_tooling/transforms.py

@@ -13,8 +13,7 @@
 from graphene_tornado.apollo_tooling.seperate_operations import separate_operations
 
 
-def hide_literals(ast):
-    # type: (Document) -> Document
+def hide_literals(ast: Document) -> Document:
     """
     Replace numeric, string, list, and object literals with "empty"
     values. Leaves enums alone (since there's no consistent "zero" enum). This
@@ -27,8 +26,7 @@ def hide_literals(ast):
     return ast
 
 
-def hide_string_and_numeric_literals(ast):
-    # type: (Document) -> Document
+def hide_string_and_numeric_literals(ast: Document) -> Document:
     """
     In the same spirit as the similarly named `hideLiterals` function, only
     hide string and numeric literals.
@@ -37,8 +35,7 @@ def hide_string_and_numeric_literals(ast):
     return ast
 
 
-def drop_unused_definitions(ast, operation_name):
-    # type: (Document, str) -> Document
+def drop_unused_definitions(ast: Document, operation_name: str) -> Document:
     """
     A GraphQL query may contain multiple named operations, with the operation to
     use specified separately by the client. This transformation drops unused
@@ -52,8 +49,7 @@ def drop_unused_definitions(ast, operation_name):
     return separated
 
 
-def sort_ast(ast):
-    # type: (Document) -> Document
+def sort_ast(ast: Document) -> Document:
     """
     sortAST sorts most multi-child nodes alphabetically. Using this as part of
     your signature calculation function may make it easier to tell the difference
@@ -65,8 +61,7 @@ def sort_ast(ast):
     return ast
 
 
-def remove_aliases(ast):
-    # type: (Document) -> Document
+def remove_aliases(ast: Document) -> Document:
     """
     removeAliases gets rid of GraphQL aliases, a feature by which you can tell a
     server to return a field's data under a different name from the field
@@ -77,8 +72,7 @@ def remove_aliases(ast):
     return ast
 
 
-def print_with_reduced_whitespace(ast):
-    # type: (Document) -> str
+def print_with_reduced_whitespace(ast: Document) -> str:
     """
     Like the graphql-js print function, but deleting whitespace wherever
     feasible. Specifically, all whitespace (outside of string literals) is

graphene_tornado/ext/apollo_engine_reporting/engine_agent.py

@@ -54,8 +54,7 @@
 EngineReportingOptions.__new__.__defaults__ = (None,) * len(EngineReportingOptions._fields)
 
 
-def _serialize(message):
-    # type: (Message) -> bytes
+def _serialize(message: Message) -> bytes:
     out = BytesIO() if six.PY3 else StringIO()
     with gzip.GzipFile(fileobj=out, mode="w") as f:
         f.write(message.SerializeToString())
@@ -71,7 +70,7 @@ def _get_trace_signature(operation_name, document_ast, query_string):
 
 class EngineReportingAgent:
 
-    def __init__(self, options, schema_hash):  # type: (EngineReportingOptions, str) -> None
+    def __init__(self, options: EngineReportingOptions, schema_hash: str) -> None:
         self.options = options
         self.api_key = options.api_key or os.getenv('ENGINE_API_KEY', None)
 
@@ -176,6 +175,6 @@ async def send_report_and_report_errors(self):
 
     def reset_report(self):
         self.report = FullTracesReport(header=self.report_header)
-        self.report_size = 0  # type: int
+        self.report_size: int = 0
 
 

graphene_tornado/ext/apollo_engine_reporting/engine_extension.py

@@ -24,8 +24,7 @@
 ])
 
 
-def generate_client_info(request):
-    # type: (HTTPServerRequest) -> ClientInfo
+def generate_client_info(request: HTTPServerRequest) -> ClientInfo:
     return ClientInfo(
         request.headers.get(CLIENT_NAME_HEADER, ''),
         request.headers.get(CLIENT_REFERENCE_HEADER_KEY, ''),
@@ -45,7 +44,7 @@ def now_ns():
 
 class EngineReportingExtension(GraphQLExtension):
 
-    def __init__(self, options, add_trace):  # type: (EngineReportingOptions, Callable) -> None
+    def __init__(self, options: EngineReportingOptions, add_trace: Callable) -> None:
         if add_trace is None:
             raise ValueError('add_trace must be defined')
 

graphene_tornado/ext/apollo_engine_reporting/schema_utils.py

@@ -8,8 +8,7 @@
 from json_stable_stringify_python import stringify
 
 
-def generate_schema_hash(schema):
-    # type: (Schema) -> str
+def generate_schema_hash(schema: Schema) -> str:
     """
     Generates a stable hash of the current schema using an introspection query.
     """

graphene_tornado/extension_stack.py

@@ -18,9 +18,9 @@ def instantiate_extensions(extensions):
 class GraphQLExtensionStack(GraphQLExtension):
 
     def __init__(self,
-                 extensions=None  # type: List[Union[Callable[[], GraphQLExtension], GraphQLExtension]]
+                 extensions: List[Union[Callable[[], GraphQLExtension], GraphQLExtension]] = None
                  ):
-        self.extensions = list(instantiate_extensions(extensions))  # type: List[GraphQLExtension]
+        self.extensions: List[GraphQLExtension] = list(instantiate_extensions(extensions))
 
     async def request_started(self, request, query_string, parsed_query, operation_name, variables, context, request_context):
         on_end = await self._handle_did_start('request_started', request, query_string, parsed_query, operation_name,

graphene_tornado/graphql_extension.py

@@ -22,54 +22,48 @@ class GraphQLExtension:
 
     @abstractmethod
     def request_started(self,
-                        request,         # type: HTTPServerRequest
-                        query_string,    # type: Optional[str],
-                        parsed_query,    # type: Optional[Document]
-                        operation_name,  # type: Optional[str]
-                        variables,       # type: Optional[dict[str, Any]]
-                        context,         # type: Any
-                        request_context  # type: Any
-                        ):
-        # type: (...) -> EndHandler
+                        request: HTTPServerRequest,
+                        query_string: Optional[str],,
+                        parsed_query: Optional[Document],
+                        operation_name: Optional[str],
+                        variables: Optional[dict[str, Any]],
+                        context: Any,
+                        request_context: Any
+                        ) -> EndHandler:
         pass
 
     @abstractmethod
-    def parsing_started(self, query_string):  # type: (str) -> EndHandler
+    def parsing_started(self, query_string: str) -> EndHandler:
         pass
 
     @abstractmethod
-    def validation_started(self):
-        # type: () -> EndHandler
+    def validation_started(self) -> EndHandler:
         pass
 
     @abstractmethod
     def execution_started(self,
-                          schema,  # type: GraphQLSchema
-                          document,  # type: Document
-                          root,  # type: Any
-                          context,  # type: Optional[Any]
-                          variables,  # type: Optional[Any]
-                          operation_name,  # type: Optional[str]
-                          request_context  # type: Dict[Any, Any]
-                          ):
-        # type: (...) -> EndHandler
+                          schema: GraphQLSchema,
+                          document: Document,
+                          root: Any,
+                          context: Optional[Any],
+                          variables: Optional[Any],
+                          operation_name: Optional[str],
+                          request_context: Dict[Any, Any]
+                          ) -> EndHandler:
         pass
 
     @abstractmethod
-    def will_resolve_field(self, root, info, **args):
-        # type: (...) -> EndHandler
+    def will_resolve_field(self, root, info, **args) -> EndHandler:
         pass
 
     @abstractmethod
     def will_send_response(self,
-                           response,  # type: Any
-                           context,   # type: Any
-                           ):
-        # type: (...) -> EndHandler
+                           response: Any,
+                           context: Any,
+                           ) -> EndHandler:
         pass
 
-    def as_middleware(self):
-        # type: () -> Callable
+    def as_middleware(self) -> Callable:
         """
         Adapter for using the stack as middleware so that the will_resolve_field function
         is invoked like normal middleware

graphene_tornado/tornado_graphql_handler.py

@@ -53,15 +53,15 @@ class TornadoGraphQLHandler(web.RequestHandler):
     request_context = {}
 
     def initialize(self,
-                   schema=None, # type: 
+                   schema=None, 
                    executor=None,
-                   middleware=None,  # type: Optional[Any]
-                   root_value=None,  # type: Any
-                   graphiql=False,  # type: bool
-                   pretty=False,  # type: bool
-                   batch=False,  # type: bool
-                   backend=None,  # type: GraphQLBackend
-                   extensions=None  # type: List[Union[Callable[[], GraphQLExtension], GraphQLExtension]]
+                   middleware: Optional[Any] = None,
+                   root_value: Any = None,
+                   graphiql: bool = False,
+                   pretty: bool = False,
+                   batch: bool = False,
+                   backend: GraphQLBackend = None,
+                   extensions: List[Union[Callable[[], GraphQLExtension], GraphQLExtension]] = None
                    ):
         super(TornadoGraphQLHandler, self).initialize()