docs: add types to recipe.party

Author: a-ungurianu

kazoo/client.py

@@ -5,6 +5,7 @@
 import logging
 from os.path import split
 import re
+from typing import Any
 import warnings
 
 import six
@@ -273,17 +274,17 @@ def __init__(
         self._stopped.set()
         self._writer_stopped.set()
 
-        self.retry = self._conn_retry = None
+        _retry = self._conn_retry = None
 
         if type(connection_retry) is dict:
             self._conn_retry = KazooRetry(**connection_retry)
         elif type(connection_retry) is KazooRetry:
             self._conn_retry = connection_retry
 
         if type(command_retry) is dict:
-            self.retry = KazooRetry(**command_retry)
+            _retry = KazooRetry(**command_retry)
         elif type(command_retry) is KazooRetry:
-            self.retry = command_retry
+            _retry = command_retry
 
         if type(self._conn_retry) is KazooRetry:
             if self.handler.sleep_func != self._conn_retry.sleep_func:
@@ -292,14 +293,14 @@ def __init__(
                     " must use the same sleep func"
                 )
 
-        if type(self.retry) is KazooRetry:
-            if self.handler.sleep_func != self.retry.sleep_func:
+        if type(_retry) is KazooRetry:
+            if self.handler.sleep_func != _retry.sleep_func:
                 raise ConfigurationError(
                     "Command retry handler and event handler "
                     "must use the same sleep func"
                 )
 
-        if self.retry is None or self._conn_retry is None:
+        if _retry is None or self._conn_retry is None:
             old_retry_keys = dict(_RETRY_COMPAT_DEFAULTS)
             for key in old_retry_keys:
                 try:
@@ -315,16 +316,16 @@ def __init__(
                 except KeyError:
                     pass
 
-            retry_keys = {}
+            retry_keys: Any = {}
             for oldname, value in old_retry_keys.items():
                 retry_keys[_RETRY_COMPAT_MAPPING[oldname]] = value
 
             if self._conn_retry is None:
                 self._conn_retry = KazooRetry(
                     sleep_func=self.handler.sleep_func, **retry_keys
                 )
-            if self.retry is None:
-                self.retry = KazooRetry(
+            if _retry is None:
+                _retry = KazooRetry(
                     sleep_func=self.handler.sleep_func, **retry_keys
                 )
 
@@ -369,14 +370,7 @@ def __init__(
             sasl_options=sasl_options,
         )
 
-        # Every retry call should have its own copy of the retry helper
-        # to avoid shared retry counts
-        self._retry = self.retry
-
-        def _retry(*args, **kwargs):
-            return self._retry.copy()(*args, **kwargs)
-
-        self.retry = _retry
+        self._retry = _retry
 
         self.Barrier = partial(Barrier, self)
         self.Counter = partial(Counter, self)
@@ -403,6 +397,12 @@ def _retry(*args, **kwargs):
                 % (kwargs.keys(),)
             )
 
+    @property
+    def retry(self) -> KazooRetry:
+        # Every retry call should have its own copy of the retry helper
+        # to avoid shared retry counts
+        return self._retry.copy()
+
     def _reset(self):
         """Resets a variety of client states for a new connection."""
         self._queue = deque()

kazoo/recipe/party.py

@@ -7,15 +7,20 @@
 used for determining members of a party.
 
 """
+from abc import ABC, abstractmethod
+from typing import Generator, List, Optional
 import uuid
+from kazoo.client import KazooClient
 
 from kazoo.exceptions import NodeExistsError, NoNodeError
 
 
-class BaseParty(object):
+class BaseParty(ABC):
     """Base implementation of a party."""
 
-    def __init__(self, client, path, identifier=None):
+    def __init__(
+        self, client: KazooClient, path: str, identifier: Optional[str] = None
+    ):
         """
         :param client: A :class:`~kazoo.client.KazooClient` instance.
         :param path: The party path to use.
@@ -29,17 +34,17 @@ def __init__(self, client, path, identifier=None):
         self.ensured_path = False
         self.participating = False
 
-    def _ensure_parent(self):
+    def _ensure_parent(self) -> None:
         if not self.ensured_path:
             # make sure our parent node exists
             self.client.ensure_path(self.path)
             self.ensured_path = True
 
-    def join(self):
+    def join(self) -> None:
         """Join the party"""
         return self.client.retry(self._inner_join)
 
-    def _inner_join(self):
+    def _inner_join(self) -> None:
         self._ensure_parent()
         try:
             self.client.create(self.create_path, self.data, ephemeral=True)
@@ -49,38 +54,49 @@ def _inner_join(self):
             # suspended connection
             self.participating = True
 
-    def leave(self):
+    def leave(self) -> bool:
         """Leave the party"""
         self.participating = False
         return self.client.retry(self._inner_leave)
 
-    def _inner_leave(self):
+    def _inner_leave(self) -> bool:
         try:
             self.client.delete(self.create_path)
         except NoNodeError:
             return False
         return True
 
-    def __len__(self):
+    def __len__(self) -> int:
         """Return a count of participating clients"""
         self._ensure_parent()
         return len(self._get_children())
 
-    def _get_children(self):
+    def _get_children(self) -> List[str]:
         return self.client.retry(self.client.get_children, self.path)
 
+    @property
+    @abstractmethod
+    def create_path(self) -> str:
+        ...
+
 
 class Party(BaseParty):
     """Simple pool of participating processes"""
 
     _NODE_NAME = "__party__"
 
-    def __init__(self, client, path, identifier=None):
+    def __init__(
+        self, client: KazooClient, path: str, identifier: Optional[str] = None
+    ):
         BaseParty.__init__(self, client, path, identifier=identifier)
         self.node = uuid.uuid4().hex + self._NODE_NAME
-        self.create_path = self.path + "/" + self.node
+        self._create_path = self.path + "/" + self.node
+
+    @property
+    def create_path(self) -> str:
+        return self._create_path
 
-    def __iter__(self):
+    def __iter__(self) -> Generator[str, None, None]:
         """Get a list of participating clients' data values"""
         self._ensure_parent()
         children = self._get_children()
@@ -93,7 +109,7 @@ def __iter__(self):
             except NoNodeError:  # pragma: nocover
                 pass
 
-    def _get_children(self):
+    def _get_children(self) -> List[str]:
         children = BaseParty._get_children(self)
         return [c for c in children if self._NODE_NAME in c]
 
@@ -109,12 +125,18 @@ class ShallowParty(BaseParty):
 
     """
 
-    def __init__(self, client, path, identifier=None):
+    def __init__(
+        self, client: KazooClient, path: str, identifier: Optional[str] = None
+    ):
         BaseParty.__init__(self, client, path, identifier=identifier)
         self.node = "-".join([uuid.uuid4().hex, self.data.decode("utf-8")])
-        self.create_path = self.path + "/" + self.node
+        self._create_path = self.path + "/" + self.node
+
+    @property
+    def create_path(self) -> str:
+        return self._create_path
 
-    def __iter__(self):
+    def __iter__(self) -> Generator[str, None, None]:
         """Get a list of participating clients' identifiers"""
         self._ensure_parent()
         children = self._get_children()

pyproject.toml

@@ -27,15 +27,14 @@ strict = true
 python_version = "3.7"
 follow_imports = "silent"
 ignore_missing_imports = true
-disable_error_code = ["no-untyped-call", "no-untyped-def"]
+disable_error_code = ["no-untyped-call", "no-untyped-def", "no-any-return"]
 files = [
     "kazoo/recipe/barrier.py",
     "kazoo/recipe/election.py",
     "kazoo/recipe/lock.py",
     "kazoo/recipe/lease.py",
     "kazoo/recipe/party.py",
-    "kazoo/recipe/counter.py",
-    "kazoo/recipe/barrier.py"
+    "kazoo/recipe/counter.py"
 ]
 
 [[tool.mypy.overrides]]