Codecov Report

+import collections+import functools+import inspect+import socket+import time+import logging++import pymemcache.exceptions as pymemexception++logger = logging.getLogger(__name__)++def retry(func):+    @functools.wraps(func)+    def func_call(*args, **kwargs):+        ntries=15+        while ntries:+            try:+                return func(*args, **kwargs)+            except pymemexception.MemcacheUnexpectedCloseError as e:

+import collections+import functools+import inspect+import socket+import time+import logging++import pymemcache.exceptions as pymemexception++logger = logging.getLogger(__name__)++def retry(func):+    @functools.wraps(func)+    def func_call(*args, **kwargs):+        ntries=15

+import collections+import functools+import inspect+import socket+import time+import logging++import pymemcache.exceptions as pymemexception++logger = logging.getLogger(__name__)++def retry(func):+    @functools.wraps(func)+    def func_call(*args, **kwargs):+        ntries=15

 class KotlinCodeGenerator(             }         } +        if (generateServer) {+            check(coroutineServiceClients) { "Server feature currently requires coroutineServiceClients to be enabled" }

+""" Module containing the RetryingClient wrapper class. """++from collections import Iterable+from time import sleep+++def _ensure_tuple_argument(argument_name, argument):+    """+    Helper function to ensure the given arguments are tuples of Exceptions (or subclasses),+    or can at least be converted to such.++    Args:+      argument_name: str, name of the argument we're checking, only used for raising meaningfull+        exceptions.+      argument: any, the argument itself.++    Returns:+      tuple[Exception]: A tuple with the elements from the argument if they are valid.++    Exceptions:+      ValueError: If the argument was not None, tuple or Iterable.+      ValueError: If any of the elements of the argument is not a subclass of Exception.+    """++    argument_tuple = None++    # Ensure the argument is a tuple, or raise an error if we can't convert it.+    if argument is None:+        return tuple()+    elif isinstance(argument, tuple):+        argument_tuple = argument+    elif isinstance(argument, Iterable) and not isinstance(argument, (str, bytes, bytearray)):+        argument_tuple = tuple(argument)+    else:+        raise ValueError("%s was not a tuple or Iterable." % argument_name)++    # Check that all the elements are actually inherited from Exception. (Catchable)+    if not all([issubclass(arg, Exception) for arg in argument_tuple]):+        raise ValueError("%s contained elements other than Exceptions." % argument_name)++class RetryingClient(object):+    """+    Client that allows retrying calls for the other clients.+    """++    def __init__(+        self,+        client,+        attempts=2,+        retry_delay=0,+        retry_for=None,+        do_not_retry_for=None+    ):+        self.client = client+        self.attempts = attempts+        self.retry_delay = retry_delay+        self.retry_for = _ensure_tuple_argument("retry_for", retry_for)+        self.do_not_retry_for = _ensure_tuple_argument("do_not_retry_for", do_not_retry_for)+++    # This is the real magic soup of the class, we catch anything that isn't strictly defined for+    # ourselves and pass it on to whatever client we've been given.+    def __getattr__(self, name, *args, **kwargs):+        # For no retry:+        # return self.client.__getattribute__(name, *args, **kwargs)+        for attempt in range(self.attempts):+            try:+                return self.client.__getattribute__(name, *args, **kwargs)+            except Exception as exc:

+""" Module containing the RetryingClient wrapper class. """++from collections import Iterable+from time import sleep+++def _ensure_tuple_argument(argument_name, argument):+    """+    Helper function to ensure the given arguments are tuples of Exceptions (or subclasses),+    or can at least be converted to such.++    Args:+      argument_name: str, name of the argument we're checking, only used for raising meaningfull+        exceptions.+      argument: any, the argument itself.++    Returns:+      tuple[Exception]: A tuple with the elements from the argument if they are valid.++    Exceptions:+      ValueError: If the argument was not None, tuple or Iterable.+      ValueError: If any of the elements of the argument is not a subclass of Exception.+    """++    argument_tuple = None++    # Ensure the argument is a tuple, or raise an error if we can't convert it.+    if argument is None:+        return tuple()+    elif isinstance(argument, tuple):+        argument_tuple = argument+    elif isinstance(argument, Iterable) and not isinstance(argument, (str, bytes, bytearray)):+        argument_tuple = tuple(argument)+    else:+        raise ValueError("%s was not a tuple or Iterable." % argument_name)++    # Check that all the elements are actually inherited from Exception. (Catchable)+    if not all([issubclass(arg, Exception) for arg in argument_tuple]):+        raise ValueError("%s contained elements other than Exceptions." % argument_name)++class RetryingClient(object):+    """+    Client that allows retrying calls for the other clients.+    """++    def __init__(+        self,+        client,+        attempts=2,+        retry_delay=0,+        retry_for=None,+        do_not_retry_for=None+    ):+        self.client = client+        self.attempts = attempts+        self.retry_delay = retry_delay+        self.retry_for = _ensure_tuple_argument("retry_for", retry_for)+        self.do_not_retry_for = _ensure_tuple_argument("do_not_retry_for", do_not_retry_for)+++    # This is the real magic soup of the class, we catch anything that isn't strictly defined for+    # ourselves and pass it on to whatever client we've been given.+    def __getattr__(self, name, *args, **kwargs):+        # For no retry:+        # return self.client.__getattribute__(name, *args, **kwargs)+        for attempt in range(self.attempts):+            try:+                return self.client.__getattribute__(name, *args, **kwargs)+            except Exception as exc:

+""" Module containing the RetryingClient wrapper class. """++from collections import Iterable+from time import sleep+++def _ensure_tuple_argument(argument_name, argument):+    """+    Helper function to ensure the given arguments are tuples of Exceptions (or subclasses),+    or can at least be converted to such.++    Args:+      argument_name: str, name of the argument we're checking, only used for raising meaningfull+        exceptions.+      argument: any, the argument itself.++    Returns:+      tuple[Exception]: A tuple with the elements from the argument if they are valid.++    Exceptions:+      ValueError: If the argument was not None, tuple or Iterable.+      ValueError: If any of the elements of the argument is not a subclass of Exception.+    """++    argument_tuple = None++    # Ensure the argument is a tuple, or raise an error if we can't convert it.+    if argument is None:+        return tuple()+    elif isinstance(argument, tuple):+        argument_tuple = argument+    elif isinstance(argument, Iterable) and not isinstance(argument, (str, bytes, bytearray)):+        argument_tuple = tuple(argument)+    else:+        raise ValueError("%s was not a tuple or Iterable." % argument_name)++    # Check that all the elements are actually inherited from Exception. (Catchable)+    if not all([issubclass(arg, Exception) for arg in argument_tuple]):+        raise ValueError("%s contained elements other than Exceptions." % argument_name)++class RetryingClient(object):+    """+    Client that allows retrying calls for the other clients.+    """++    def __init__(+        self,+        client,+        attempts=2,+        retry_delay=0,+        retry_for=None,+        do_not_retry_for=None+    ):+        self.client = client+        self.attempts = attempts+        self.retry_delay = retry_delay+        self.retry_for = _ensure_tuple_argument("retry_for", retry_for)+        self.do_not_retry_for = _ensure_tuple_argument("do_not_retry_for", do_not_retry_for)+++    # This is the real magic soup of the class, we catch anything that isn't strictly defined for+    # ourselves and pass it on to whatever client we've been given.+    def __getattr__(self, name, *args, **kwargs):+        # For no retry:+        # return self.client.__getattribute__(name, *args, **kwargs)+        for attempt in range(self.attempts):+            try:+                return self.client.__getattribute__(name, *args, **kwargs)+            except Exception as exc:

+""" Module containing the RetryingClient wrapper class. """++from collections import Iterable+from time import sleep+++def _ensure_tuple_argument(argument_name, argument):+    """+    Helper function to ensure the given arguments are tuples of Exceptions (or subclasses),+    or can at least be converted to such.++    Args:+      argument_name: str, name of the argument we're checking, only used for raising meaningfull+        exceptions.+      argument: any, the argument itself.++    Returns:+      tuple[Exception]: A tuple with the elements from the argument if they are valid.++    Exceptions:+      ValueError: If the argument was not None, tuple or Iterable.+      ValueError: If any of the elements of the argument is not a subclass of Exception.+    """++    argument_tuple = None++    # Ensure the argument is a tuple, or raise an error if we can't convert it.+    if argument is None:+        return tuple()+    elif isinstance(argument, tuple):+        argument_tuple = argument+    elif isinstance(argument, Iterable) and not isinstance(argument, (str, bytes, bytearray)):+        argument_tuple = tuple(argument)+    else:+        raise ValueError("%s was not a tuple or Iterable." % argument_name)++    # Check that all the elements are actually inherited from Exception. (Catchable)+    if not all([issubclass(arg, Exception) for arg in argument_tuple]):+        raise ValueError("%s contained elements other than Exceptions." % argument_name)++class RetryingClient(object):+    """+    Client that allows retrying calls for the other clients.+    """++    def __init__(+        self,+        client,+        attempts=2,+        retry_delay=0,+        retry_for=None,+        do_not_retry_for=None+    ):+        self.client = client+        self.attempts = attempts+        self.retry_delay = retry_delay+        self.retry_for = _ensure_tuple_argument("retry_for", retry_for)+        self.do_not_retry_for = _ensure_tuple_argument("do_not_retry_for", do_not_retry_for)+++    # This is the real magic soup of the class, we catch anything that isn't strictly defined for+    # ourselves and pass it on to whatever client we've been given.+    def __getattr__(self, name, *args, **kwargs):+        # For no retry:+        # return self.client.__getattribute__(name, *args, **kwargs)+        for attempt in range(self.attempts):+            try:+                return self.client.__getattribute__(name, *args, **kwargs)+            except Exception as exc:++                if attempt == self.attempts:

+""" Module containing the RetryingClient wrapper class. """++from collections import Iterable+from time import sleep+++def _ensure_tuple_argument(argument_name, argument):+    """+    Helper function to ensure the given arguments are tuples of Exceptions (or subclasses),+    or can at least be converted to such.++    Args:+      argument_name: str, name of the argument we're checking, only used for raising meaningfull+        exceptions.+      argument: any, the argument itself.++    Returns:+      tuple[Exception]: A tuple with the elements from the argument if they are valid.++    Exceptions:+      ValueError: If the argument was not None, tuple or Iterable.+      ValueError: If any of the elements of the argument is not a subclass of Exception.+    """++    argument_tuple = None++    # Ensure the argument is a tuple, or raise an error if we can't convert it.+    if argument is None:+        return tuple()+    elif isinstance(argument, tuple):+        argument_tuple = argument+    elif isinstance(argument, Iterable) and not isinstance(argument, (str, bytes, bytearray)):+        argument_tuple = tuple(argument)+    else:+        raise ValueError("%s was not a tuple or Iterable." % argument_name)++    # Check that all the elements are actually inherited from Exception. (Catchable)+    if not all([issubclass(arg, Exception) for arg in argument_tuple]):+        raise ValueError("%s contained elements other than Exceptions." % argument_name)++class RetryingClient(object):+    """+    Client that allows retrying calls for the other clients.+    """++    def __init__(+        self,+        client,+        attempts=2,+        retry_delay=0,+        retry_for=None,+        do_not_retry_for=None+    ):+        self.client = client+        self.attempts = attempts+        self.retry_delay = retry_delay+        self.retry_for = _ensure_tuple_argument("retry_for", retry_for)+        self.do_not_retry_for = _ensure_tuple_argument("do_not_retry_for", do_not_retry_for)+++    # This is the real magic soup of the class, we catch anything that isn't strictly defined for+    # ourselves and pass it on to whatever client we've been given.+    def __getattr__(self, name, *args, **kwargs):+        # For no retry:+        # return self.client.__getattribute__(name, *args, **kwargs)+        for attempt in range(self.attempts):+            try:+                return self.client.__getattribute__(name, *args, **kwargs)+            except Exception as exc:++                if attempt == self.attempts:+                    # If we're at the limit, just raise the exception to caller.+                    # Exception type doesn't matter.+                    raise exc+                elif isinstance(exc, self.retry_for) or not isinstance(exc, self.do_not_retry_for):

+""" Module containing the RetryingClient wrapper class. """++from collections import Iterable+from time import sleep+++def _ensure_tuple_argument(argument_name, argument):+    """+    Helper function to ensure the given arguments are tuples of Exceptions (or subclasses),+    or can at least be converted to such.++    Args:+      argument_name: str, name of the argument we're checking, only used for raising meaningfull+        exceptions.+      argument: any, the argument itself.++    Returns:+      tuple[Exception]: A tuple with the elements from the argument if they are valid.++    Exceptions:+      ValueError: If the argument was not None, tuple or Iterable.+      ValueError: If any of the elements of the argument is not a subclass of Exception.+    """++    argument_tuple = None++    # Ensure the argument is a tuple, or raise an error if we can't convert it.+    if argument is None:+        return tuple()+    elif isinstance(argument, tuple):+        argument_tuple = argument+    elif isinstance(argument, Iterable) and not isinstance(argument, (str, bytes, bytearray)):+        argument_tuple = tuple(argument)+    else:+        raise ValueError("%s was not a tuple or Iterable." % argument_name)++    # Check that all the elements are actually inherited from Exception. (Catchable)+    if not all([issubclass(arg, Exception) for arg in argument_tuple]):+        raise ValueError("%s contained elements other than Exceptions." % argument_name)++class RetryingClient(object):+    """+    Client that allows retrying calls for the other clients.+    """++    def __init__(+        self,+        client,+        attempts=2,+        retry_delay=0,+        retry_for=None,+        do_not_retry_for=None+    ):+        self.client = client+        self.attempts = attempts+        self.retry_delay = retry_delay+        self.retry_for = _ensure_tuple_argument("retry_for", retry_for)+        self.do_not_retry_for = _ensure_tuple_argument("do_not_retry_for", do_not_retry_for)+++    # This is the real magic soup of the class, we catch anything that isn't strictly defined for+    # ourselves and pass it on to whatever client we've been given.+    def __getattr__(self, name, *args, **kwargs):+        # For no retry:+        # return self.client.__getattribute__(name, *args, **kwargs)+        for attempt in range(self.attempts):+            try:+                return self.client.__getattribute__(name, *args, **kwargs)+            except Exception as exc:

+""" Module containing the RetryingClient wrapper class. """++from collections import Iterable+from time import sleep+++def _ensure_tuple_argument(argument_name, argument):+    """+    Helper function to ensure the given arguments are tuples of Exceptions (or subclasses),+    or can at least be converted to such.++    Args:+      argument_name: str, name of the argument we're checking, only used for raising meaningfull+        exceptions.+      argument: any, the argument itself.++    Returns:+      tuple[Exception]: A tuple with the elements from the argument if they are valid.++    Exceptions:+      ValueError: If the argument was not None, tuple or Iterable.+      ValueError: If any of the elements of the argument is not a subclass of Exception.+    """++    argument_tuple = None++    # Ensure the argument is a tuple, or raise an error if we can't convert it.+    if argument is None:+        return tuple()+    elif isinstance(argument, tuple):+        argument_tuple = argument+    elif isinstance(argument, Iterable) and not isinstance(argument, (str, bytes, bytearray)):+        argument_tuple = tuple(argument)+    else:+        raise ValueError("%s was not a tuple or Iterable." % argument_name)++    # Check that all the elements are actually inherited from Exception. (Catchable)+    if not all([issubclass(arg, Exception) for arg in argument_tuple]):+        raise ValueError("%s contained elements other than Exceptions." % argument_name)++class RetryingClient(object):+    """+    Client that allows retrying calls for the other clients.+    """++    def __init__(+        self,+        client,+        attempts=2,+        retry_delay=0,+        retry_for=None,+        do_not_retry_for=None+    ):+        self.client = client+        self.attempts = attempts+        self.retry_delay = retry_delay+        self.retry_for = _ensure_tuple_argument("retry_for", retry_for)+        self.do_not_retry_for = _ensure_tuple_argument("do_not_retry_for", do_not_retry_for)+++    # This is the real magic soup of the class, we catch anything that isn't strictly defined for+    # ourselves and pass it on to whatever client we've been given.+    def __getattr__(self, name, *args, **kwargs):+        # For no retry:+        # return self.client.__getattribute__(name, *args, **kwargs)