Added support for protocols

Fixes #83.

docs/index.rst

@@ -202,6 +202,8 @@ Type           Notes
 ``List``       Contents are typechecked
 ``Literal``
 ``NamedTuple`` Field values are typechecked
+``Protocol``   Value type checked with ``issubclass()`` against the
+               protocol
 ``Set``        Contents are typechecked
 ``Sequence``   Contents are typechecked
 ``Tuple``      Contents are typechecked

docs/versionhistory.rst

@@ -5,6 +5,7 @@ This library adheres to `Semantic Versioning 2.0 <https://semver.org/#semantic-v
 
 **UNRELEASED**
 
+- Added support for ``typing.Protocol`` subclasses
 - Fixed the handling of ``total=False`` in ``TypedDict``
 - Removed support of default values in ``TypedDict``, as they are not supported in the spec
 

tests/test_typeguard.py

@@ -6,7 +6,7 @@
 from io import StringIO, BytesIO
 from typing import (
     Any, Callable, Dict, List, Set, Tuple, Union, TypeVar, Sequence, NamedTuple, Iterable,
-    Container, Generic, BinaryIO, TextIO, Generator, Iterator)
+    Container, Generic, BinaryIO, TextIO, Generator, Iterator, SupportsInt)
 
 import pytest
 
@@ -1068,6 +1068,21 @@ def func(x: annotation) -> None:
         func(Child())
         pytest.raises(TypeError, func, 'foo')
 
+    @pytest.mark.parametrize('value, error_re', [
+        (1, None),
+        ('foo',
+         r'type of argument "arg" \(str\) is not compatible with the SupportsInt protocol')
+    ], ids=['int', 'str'])
+    def test_protocol(self, value, error_re):
+        @typechecked
+        def foo(arg: SupportsInt):
+            pass
+
+        if error_re:
+            pytest.raises(TypeError, foo, value).match(error_re)
+        else:
+            foo(value)
+
 
 class TestTypeChecker:
     @pytest.fixture

typeguard/__init__.py

@@ -9,7 +9,7 @@
 from collections import OrderedDict
 from enum import Enum
 from functools import wraps, partial
-from inspect import Parameter, isclass, isfunction, isgeneratorfunction
+from inspect import Parameter, isclass, isfunction, isgeneratorfunction, getattr_static
 from io import TextIOBase, RawIOBase, IOBase, BufferedIOBase
 from traceback import extract_stack, print_stack
 from types import CodeType, FunctionType
@@ -25,6 +25,11 @@
 except ImportError:
     Literal = TypedDict = None
 
+try:
+    from typing import Protocol
+except ImportError:
+    from typing import _Protocol as Protocol
+
 try:
     from typing import AsyncGenerator
 except ImportError:
@@ -481,6 +486,12 @@ def check_io(argname: str, value, expected_type):
                         format(argname, qualified_name(value.__class__)))
 
 
+def check_protocol(argname: str, value, expected_type):
+    if not issubclass(type(value), expected_type):
+        raise TypeError('type of {} ({}) is not compatible with the {} protocol'.
+                        format(argname, type(value).__qualname__, expected_type.__qualname__))
+
+
 # Equality checks are applied to these
 origin_type_checkers = {
     Callable: check_callable,
@@ -558,6 +569,8 @@ def check_type(argname: str, value, expected_type, memo: Optional[_CallMemo] = N
             check_io(argname, value, expected_type)
         elif issubclass(expected_type, dict) and hasattr(expected_type, '__annotations__'):
             check_typed_dict(argname, value, expected_type, memo)
+        elif getattr_static(expected_type, '_is_protocol', False):
+            check_protocol(argname, value, expected_type)
         else:
             expected_type = (getattr(expected_type, '__extra__', None) or origin_type or
                              expected_type)