apply com2ann

Author: graingert

docs/source/conf.py

@@ -56,7 +56,7 @@
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = []  # type: List[str]
+exclude_patterns: List[str] = []
 
 # Example configuration for intersphinx: refer to the Python standard library.
 intersphinx_mapping = {'http://docs.python.org/': None}

src/priority/priority.py

@@ -89,22 +89,22 @@ class Stream:
     :param weight: (optional) The stream weight. Defaults to 16.
     """
 
-    def __init__(self, stream_id, weight=16):  # type: (int, int) -> None
+    def __init__(self, stream_id: int, weight: int = 16) -> None:
         self.stream_id = stream_id
         self.weight = weight
-        self.children = []  # type: List[Stream]
-        self.parent = None  # type: Optional[Stream]
-        self.child_queue = []  # type: List[Tuple[int, Stream]]
+        self.children: List[Stream] = []
+        self.parent: Optional[Stream] = None
+        self.child_queue: List[Tuple[int, Stream]] = []
         self.active = True
         self.last_weight = 0
         self._deficit = 0
 
     @property
-    def weight(self):  # type: () -> int
+    def weight(self) -> int:
         return self._weight
 
     @weight.setter
-    def weight(self, value):  # type: (int) -> None
+    def weight(self, value: int) -> None:
         # RFC 7540 § 5.3.2: "All dependent streams are allocated an integer
         # weight between 1 and 256 (inclusive)."
         if not isinstance(value, int):
@@ -115,7 +115,7 @@ def weight(self, value):  # type: (int) -> None
             )
         self._weight = value
 
-    def add_child(self, child):  # type: (Stream) -> None
+    def add_child(self, child: Stream) -> None:
         """
         Add a stream that depends on this one.
 
@@ -125,7 +125,7 @@ def add_child(self, child):  # type: (Stream) -> None
         self.children.append(child)
         heapq.heappush(self.child_queue, (self.last_weight, child))
 
-    def add_child_exclusive(self, child):  # type: (Stream) -> None
+    def add_child_exclusive(self, child: Stream) -> None:
         """
         Add a stream that exclusively depends on this one.
 
@@ -142,10 +142,9 @@ def add_child_exclusive(self, child):  # type: (Stream) -> None
 
     def remove_child(
         self,
-        child,  # type: Stream
-        strip_children=True,  # type: bool
-    ):
-        # type: (...) -> None
+        child: Stream,
+        strip_children: bool = True,
+    ) -> None:
         """
         Removes a child stream from this stream. This is a potentially somewhat
         expensive operation.
@@ -161,7 +160,7 @@ def remove_child(
         #   it in the old one
         self.children.remove(child)
 
-        new_queue = []  # type: List[Tuple[int, Stream]]
+        new_queue: List[Tuple[int, Stream]] = []
 
         while self.child_queue:
             level, stream = heapq.heappop(self.child_queue)
@@ -176,7 +175,7 @@ def remove_child(
             for new_child in child.children:
                 self.add_child(new_child)
 
-    def schedule(self):  # type: () -> int
+    def schedule(self) -> int:
         """
         Returns the stream ID of the next child to schedule. Potentially
         recurses down the tree of priorities.
@@ -216,45 +215,45 @@ def schedule(self):  # type: () -> int
         return next_stream
 
     # Custom repr
-    def __repr__(self):  # type: () -> str
+    def __repr__(self) -> str:
         return "Stream<id=%d, weight=%d>" % (self.stream_id, self.weight)
 
     # Custom comparison
-    def __eq__(self, other):  # type: (object) -> bool
+    def __eq__(self, other: object) -> bool:
         if not isinstance(other, Stream):  # pragma: no cover
             return False
 
         return self.stream_id == other.stream_id
 
-    def __ne__(self, other):  # type: (object) -> bool
+    def __ne__(self, other: object) -> bool:
         return not self.__eq__(other)
 
-    def __lt__(self, other):  # type: (Stream) -> bool
+    def __lt__(self, other: Stream) -> bool:
         if not isinstance(other, Stream):  # pragma: no cover
             return NotImplemented
 
         return self.stream_id < other.stream_id
 
-    def __le__(self, other):  # type: (Stream) -> bool
+    def __le__(self, other: Stream) -> bool:
         if not isinstance(other, Stream):  # pragma: no cover
             return NotImplemented
 
         return self.stream_id <= other.stream_id
 
-    def __gt__(self, other):  # type: (Stream) -> bool
+    def __gt__(self, other: Stream) -> bool:
         if not isinstance(other, Stream):  # pragma: no cover
             return NotImplemented
 
         return self.stream_id > other.stream_id
 
-    def __ge__(self, other):  # type: (Stream) -> bool
+    def __ge__(self, other: Stream) -> bool:
         if not isinstance(other, Stream):  # pragma: no cover
             return NotImplemented
 
         return self.stream_id >= other.stream_id
 
 
-def _stream_cycle(new_parent, current):  # type: (Stream, Stream) -> bool
+def _stream_cycle(new_parent: Stream, current: Stream) -> bool:
     """
     Reports whether the new parent depends on the current stream.
     """
@@ -301,7 +300,7 @@ class PriorityTree:
     :type maximum_streams: ``int``
     """
 
-    def __init__(self, maximum_streams=1000):  # type: (int) -> None
+    def __init__(self, maximum_streams: int = 1000) -> None:
         # This flat array keeps hold of all the streams that are logically
         # dependent on stream 0.
         self._root_stream = Stream(stream_id=0, weight=1)
@@ -314,7 +313,7 @@ def __init__(self, maximum_streams=1000):  # type: (int) -> None
             raise ValueError("maximum_streams must be a positive integer.")
         self._maximum_streams = maximum_streams
 
-    def _get_or_insert_parent(self, parent_stream_id):  # type: (int) -> Stream
+    def _get_or_insert_parent(self, parent_stream_id: int) -> Stream:
         """
         When inserting or reprioritizing a stream it is possible to make it
         dependent on a stream that is no longer in the tree. In this situation,
@@ -330,10 +329,9 @@ def _get_or_insert_parent(self, parent_stream_id):  # type: (int) -> Stream
 
     def _exclusive_insert(
         self,
-        parent_stream,  # type: Stream
-        inserted_stream,  # type: Stream
-    ):
-        # type: (...) -> None
+        parent_stream: Stream,
+        inserted_stream: Stream,
+    ) -> None:
         """
         Insert ``inserted_stream`` beneath ``parent_stream``, obeying the
         semantics of exclusive insertion.
@@ -342,12 +340,11 @@ def _exclusive_insert(
 
     def insert_stream(
         self,
-        stream_id,  # type: int
-        depends_on=None,  # type: Optional[int]
-        weight=16,  # type: int
-        exclusive=False,  # type: bool
-    ):
-        # type: (...) -> None
+        stream_id: int,
+        depends_on: Optional[int] = None,
+        weight: int = 16,
+        exclusive: bool = False,
+    ) -> None:
         """
         Insert a stream into the tree.
 
@@ -389,12 +386,11 @@ def insert_stream(
 
     def reprioritize(
         self,
-        stream_id,  # type: int
-        depends_on=None,  # type: Optional[int]
-        weight=16,  # type: int
-        exclusive=False,  # type: bool
-    ):
-        # type: (...) -> None
+        stream_id: int,
+        depends_on: Optional[int] = None,
+        weight: int = 16,
+        exclusive: bool = False,
+    ) -> None:
         """
         Update the priority status of a stream already in the tree.
 
@@ -453,7 +449,7 @@ def reprioritize(
         else:
             new_parent.add_child(current_stream)
 
-    def remove_stream(self, stream_id):  # type: (int) -> None
+    def remove_stream(self, stream_id: int) -> None:
         """
         Removes a stream from the priority tree.
 
@@ -470,7 +466,7 @@ def remove_stream(self, stream_id):  # type: (int) -> None
         parent = child.parent
         parent.remove_child(child)  # type: ignore[union-attr]
 
-    def block(self, stream_id):  # type: (int) -> None
+    def block(self, stream_id: int) -> None:
         """
         Marks a given stream as blocked, with no data to send.
 
@@ -484,7 +480,7 @@ def block(self, stream_id):  # type: (int) -> None
         except KeyError:
             raise MissingStreamError("Stream %d not in tree" % stream_id)
 
-    def unblock(self, stream_id):  # type: (int) -> None
+    def unblock(self, stream_id: int) -> None:
         """
         Marks a given stream as unblocked, with more data to send.
 
@@ -499,14 +495,14 @@ def unblock(self, stream_id):  # type: (int) -> None
             raise MissingStreamError("Stream %d not in tree" % stream_id)
 
     # The iterator protocol
-    def __iter__(self):  # type: () -> PriorityTree  # pragma: no cover
+    def __iter__(self) -> PriorityTree:  # pragma: no cover
         return self
 
-    def __next__(self):  # type: () -> int  # pragma: no cover
+    def __next__(self) -> int:  # pragma: no cover
         try:
             return self._root_stream.schedule()
         except IndexError:
             raise DeadlockError("No unblocked streams to schedule.")
 
-    def next(self):  # type: () -> int  # pragma: no cover
+    def next(self) -> int:  # pragma: no cover
         return self.__next__()

test/test_priority.py

@@ -59,10 +59,9 @@ def readme_tree():
 
 
 def active_readme_streams_from_filter(
-    filtered,  # type: Iterable[int]
-    blocked=True,  # type: bool
-):
-    # type: (...) -> List[int]
+    filtered: Iterable[int],
+    blocked: bool = True,
+) -> List[int]:
     """
     Given a collection of filtered streams, determine which ones are active.
     This applies only to the readme tree at this time, though in future it
@@ -84,7 +83,7 @@ def active_readme_streams_from_filter(
     }
     filtered = set(filtered)
 
-    def get_expected(tree):  # type: (Dict[Any, Any]) -> List[int]
+    def get_expected(tree: Dict[Any, Any]) -> List[int]:
         expected = []
 
         for stream_id in tree: