import re
from pytypes import TypeChecker

with TypeChecker():
    re.compile('a')

$ python3 Test.py 
/usr/local/lib/python3.6/dist-packages/pytypes-1.0b5.post20-py3.6.egg/pytypes/type_util.py:2532: UserWarning: the system profiling hook has changed unexpectedly
  warn('the system profiling hook has changed unexpectedly')
Traceback (most recent call last):
  File "/usr/local/lib/python3.6/dist-packages/pytypes-1.0b5.post20-py3.6.egg/pytypes/typecomment_parser.py", line 52, in _get_typestrings
    srclines = inspect.getsourcelines(obj)[0]
  File "/usr/lib/python3.6/inspect.py", line 955, in getsourcelines
    lines, lnum = findsource(object)
  File "/usr/lib/python3.6/inspect.py", line 768, in findsource
    file = getsourcefile(object)
  File "/usr/lib/python3.6/inspect.py", line 684, in getsourcefile
    filename = getfile(object)
  File "/usr/lib/python3.6/inspect.py", line 666, in getfile
    'function, traceback, frame, or code object'.format(object))
TypeError: <slot wrapper '__and__' of 'int' objects> is not a module, class, method, function, traceback, frame, or code object

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "Test.py", line 5, in <module>
    re.compile('a')
  File "/usr/lib/python3.6/re.py", line 233, in compile
    return _compile(pattern, flags)
  File "/usr/lib/python3.6/re.py", line 302, in _compile
    if not (flags & DEBUG):
  File "/usr/lib/python3.6/enum.py", line 803, in __and__
    def __and__(self, other):
  File "/usr/local/lib/python3.6/dist-packages/pytypes-1.0b5.post20-py3.6.egg/pytypes/type_util.py", line 2563, in __call__
    _check_caller_type(False, caller_level=self._caller_level_shift+1)
  File "/usr/local/lib/python3.6/dist-packages/pytypes-1.0b5.post20-py3.6.egg/pytypes/type_util.py", line 2416, in _check_caller_type
    cllable, clss = _find_typed_base_method(cllable, clss)
  File "/usr/local/lib/python3.6/dist-packages/pytypes-1.0b5.post20-py3.6.egg/pytypes/type_util.py", line 2131, in _find_typed_base_method
    if has_type_hints(util._actualfunc(fmeth)):
  File "/usr/local/lib/python3.6/dist-packages/pytypes-1.0b5.post20-py3.6.egg/pytypes/type_util.py", line 657, in has_type_hints
    return _has_type_hints(func0)
  File "/usr/local/lib/python3.6/dist-packages/pytypes-1.0b5.post20-py3.6.egg/pytypes/type_util.py", line 686, in _has_type_hints
    tpStr = _get_typestrings(func, False)
  File "/usr/local/lib/python3.6/dist-packages/pytypes-1.0b5.post20-py3.6.egg/pytypes/typecomment_parser.py", line 54, in _get_typestrings
    srclines = inspect.getsourcelines(getattr(obj.__class__, obj.__name__))[0]
AttributeError: type object 'wrapper_descriptor' has no attribute '__and__'

#Python 3.6.2 | packaged by conda-forge | (default, Jul 23 2017, 23:01:38)
#Type 'copyright', 'credits' or 'license' for more information
#IPython 6.2.1 -- An enhanced Interactive Python. Type '?' for help.

In [1]: import pytypes

In [2]: issubclass(int, float)
Out[2]: False

In [3]: pytypes.is_subtype(int, float)
Out[3]: True

from typing import Iterator

from pytypes import TypeChecker

def f() -> Iterator[str]:
    yield 'abc'

with TypeChecker():
    x = tuple(c for c in f())
    print("OK")

$ python3 Test.py
Traceback (most recent call last):
  File "Test.py", line 9, in <module>
    x = tuple(c for c in f())
  File "Test.py", line 9, in <genexpr>
    x = tuple(c for c in f())
  File "Test.py", line 6, in f
    yield 'abc'
pytypes.exceptions.ReturnTypeError: 
  __main__.f
  returned incompatible type:
Expected: Iterator[str]
Received: str

$ python3 Test.py
Exception ignored in: <generator object f at 0x7fe74e4b7db0>
Traceback (most recent call last):
  File "Test.py", line 5, in f
    def f() -> Iterator[str]:
  File "/usr/local/lib/python3.6/dist-packages/pytypes-1.0b5.post23-py3.6.egg/pytypes/type_util.py", line 2580, in __call__
    _check_caller_type(True, None, arg, caller_level=self._caller_level_shift+1)
  File "/usr/local/lib/python3.6/dist-packages/pytypes-1.0b5.post23-py3.6.egg/pytypes/type_util.py", line 2431, in _check_caller_type
    prop_getter, force_exception=True)
  File "/usr/local/lib/python3.6/dist-packages/pytypes-1.0b5.post23-py3.6.egg/pytypes/typechecker.py", line 718, in _checkfuncresult
    _raise_typecheck_error(msg, True, check_val, tpch, resSig, func)
  File "/usr/local/lib/python3.6/dist-packages/pytypes-1.0b5.post23-py3.6.egg/pytypes/type_util.py", line 2336, in _raise_typecheck_error
    raise pytypes.ReturnTypeError(msg)
pytypes.exceptions.ReturnTypeError: 
  __main__.f
  returned incompatible type:
Expected: Iterator[str]
Received: NoneType
OK

import typing
import pytypes
from pytypes import type_util

type_util._issubclass(typing.List[typing.Dict[str, str]], typing.List[dict])

from autoclass import autoclass, Boolean
from pytypes import typechecked
from numbers import Real, Integral
from typing import Optional

@typechecked
@autoclass
class HouseConfiguration(object):
    def __init__(self,
                 name: str,
                 surface: Real,
                 nb_floors: Optional[Integral] = 1,
                 with_windows: Boolean = False):
        pass

    # -- overriden setter for surface for custom validation
    @setter_override
    def surface(self, surface):
        assert surface > 0
        self._surface = surface

t = HouseConfiguration('test', 12, 2)  # error

t = HouseConfiguration('test', 12, nb_floors=2)

from pytypes import typechecked
from inspect import signature

class Foo:
    def __init__(self, foo: str = 'hello'):
        self.foo = foo

s = signature(Foo.__init__)
print(s.parameters)
# > OrderedDict([('self', <Parameter "self">), ('foo', <Parameter "foo:str='hello'">)])
# parameter names, type hints and default values are preserved

@typechecked
class Foo:
    def __init__(self, foo: str):
        self.foo = foo

s = signature(Foo.__init__)
print(s.parameters)
# > OrderedDict([('args', <Parameter "*args">), ('kw', <Parameter "**kw">)])
# everything has been removed ! 

from configparser import ConfigParser
from pytypes import TypeChecker

with TypeChecker():
    ConfigParser()

$ python3 Test.py
/usr/local/lib/python3.6/dist-packages/pytypes/type_util.py:2399: UserWarning: the system profiling hook has changed unexpectedly
  warn('the system profiling hook has changed unexpectedly')
Traceback (most recent call last):
  File "Test.py", line 5, in <module>
    ConfigParser()
  File "/usr/lib/python3.6/configparser.py", line 612, in __init__
    self._proxies[default_section] = SectionProxy(self, default_section)
  File "/usr/lib/python3.6/configparser.py", line 1223, in __init__
    for conv in parser.converters:
  File "/usr/lib/python3.6/configparser.py", line 1181, in converters
    return self._converters
  File "/usr/local/lib/python3.6/dist-packages/pytypes/type_util.py", line 2446, in __call__
    _check_caller_type(True, None, arg, caller_level=self._caller_level_shift+1)
  File "/usr/local/lib/python3.6/dist-packages/pytypes/type_util.py", line 2247, in _check_caller_type
    orig_clss = call_args[0].__orig_class__
  File "/usr/lib/python3.6/configparser.py", line 1306, in __getitem__
    return self._data[key]
KeyError: 0

from typing import cast, List

from pytypes import TypeChecker

def f() -> List[float]:
    return cast(List[float], [2])

with TypeChecker():
    f()
    print("OK")

$ python3 Test.py
Traceback (most recent call last):
  File "Test.py", line 9, in <module>
    f()
  File "Test.py", line 6, in f
    return cast(List[float], [2])
pytypes.exceptions.ReturnTypeError: 
  __main__.f
  returned incompatible type:
Expected: List[float]
Received: List[int]

>>> from pytypes import type_util
>>> import typing
>>> type_util._isinstance((), typing.List)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: issubclass() arg 2 must be a class or tuple of classes
>>> type_util._isinstance((), typing.List[typing.Any])

>>> import typing
>>> import collections
>>> import pytypes
>>> pytypes.is_of_type(collections.defaultdict(list), typing.Dict[str, typing.List])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Parameterized generics cannot be used with class or instance checks

from typing import List, Mapping

from pytypes import TypeChecker

def f() -> List[Mapping[int, str]]:
    return [{}]

with TypeChecker():
    f()
    print("OK")

$ python3 Test.py
Traceback (most recent call last):
  File "Test.py", line 9, in <module>
    f()
  File "Test.py", line 6, in f
    return [{}]
pytypes.exceptions.ReturnTypeError: 
  __main__.f
  returned incompatible type:
Expected: List[Mapping[int, str]]
Received: List[Empty[Dict]]

from pytypes import type_util
value = (i for i in range(10))
type_util._isinstance(value, int)

from pytypes import type_util

class Foo:
    def bar(self):
        value = (i for i in range(10))
        type_util._isinstance(value, int)

Foo().bar()

from typing import *

A = TypeVar('A')

class Foo(Generic[A]):
    pass

class Bar(Foo):
    pass

from typing import Iterable

class MyIterable(Iterable): # Same as Iterable[Any]

import typing as tp

import pytypes


T = tp.TypeVar("T")
T1 = tp.TypeVar("T1")
T2 = tp.TypeVar("T2")


class D0(tp.Dict[T1, T2]):
    def show_types(self) -> None:
        gt = pytypes.get_Generic_type(self)
        print(gt, pytypes.get_Generic_parameters(gt, D0))


class D1(D0[int, T]):
    pass


class D2(D1[str]):
    pass


D0[int, str]().show_types()
D1[str]().show_types()
D2().show_types()

from collections import OrderedDict
from typing import Mapping

from pytypes import TypeChecker

def f() -> Mapping[int, str]:
    return OrderedDict()

with TypeChecker():
    f()

$ python3 Test.py 
Traceback (most recent call last):
  File "Test.py", line 11, in <module>
    f()
  File "Test.py", line 8, in f
    return OrderedDict()
pytypes.exceptions.ReturnTypeError: 
  __main__.f
  returned incompatible type:
Expected: Mapping[int, str]
Received: OrderedDict

from pytypes import TypeChecker

class A:
    def __init__(self) -> None:
        pass

with TypeChecker():
    A()

$ python3 Test.py 
Traceback (most recent call last):
  File "Test.py", line 8, in <module>
    A()
  File "Test.py", line 5, in __init__
    pass
pytypes.exceptions.ReturnTypeError: 
  __main__.A.__init__
  returned incompatible type:
Expected: NoneType
Received: Tuple[A]

from typing import Callable, List

from pytypes import TypeChecker

def n() -> None:
    pass

def f() -> List[Callable[[], None]]:
    return [n]

with TypeChecker():
    f()
    print("OK")

$ python3 Test.py
Traceback (most recent call last):
  File "Test.py", line 12, in <module>
    f()
  File "Test.py", line 9, in f
    return [n]
pytypes.exceptions.ReturnTypeError: 
  __main__.f
  returned incompatible type:
Expected: List[Callable[[], NoneType]]
Received: List[function]

>>> import typing
>>> from pytypes import type_util
>>> type_util._isinstance(frozenset({1, 2, 'a', None, 'b'}), typing.AbstractSet[typing.Union[str, int, None]])
False
>>> type_util._isinstance({1, 2, 'a', None, 'b'}, typing.AbstractSet[typing.Union[str, int, type(None)]])
True
>>> issubclass(frozenset, typing.AbstractSet)
True

from typing import Any, Tuple

from pytypes import TypeChecker

def f() -> Tuple[Any, ...]:
    return ()

with TypeChecker():
    f()
    print("OK")

$ python3 Test.py
Traceback (most recent call last):
  File "Test.py", line 9, in <module>
    f()
  File "Test.py", line 6, in f
    return ()
pytypes.exceptions.ReturnTypeError: 
  __main__.f
  returned incompatible type:
Expected: Tuple[Any]
Received: Tuple[]

# util.pyi
from typing import Union

MagicParam = Union[int, float]

# magic.pyi
from .util import MagicParam

def a() -> MagicParam: ...

from typing import Dict
from pytypes import typechecked

@typechecked
def foo(a: Dict):
    pass

foo({'name': 'test2', 'surface': 1})

if prop or prop_getter:
    slf = True
    util._warn_argname('property using non-idiomatic self argname',
            func0, slf, clsm)
    check_args = args_kw[1:] # omit self
 check_args = args_kw # <--- will always overwrite the `check_args` from the previous line!

if prop or prop_getter:
    slf = True
    util._warn_argname('property using non-idiomatic self argname',
            func0, slf, clsm)
    check_args = args_kw[1:] # omit self
else:
    check_args = args_kw

from typing import Iterable

from pytypes import TypeChecker

def f(a: Iterable[str]) -> None:
    pass

with TypeChecker():
    f((c for c in 'abc'))
    print("OK")

$ python3 Test.py
Traceback (most recent call last):
  File "Test.py", line 9, in <module>
    f((c for c in 'abc'))
  File "Test.py", line 5, in f
    def f(a: Iterable[str]) -> None:
pytypes.exceptions.InputTypeError: 
  __main__.f
  called with incompatible types:
Expected: Tuple[Iterable[str]]
Received: Tuple[Generator]

from typing import TypeVar, Generic, Iterator
from pytypes import typechecked

T = TypeVar('T')

class TypList(Generic[T], list):

    @typechecked
    def append(self, obj: T) -> None:
        super().append(obj)

    @typechecked
    def extend(self, iterable: Iterator[T]) -> None:
        super().extend(iterable)

    @typechecked
    def insert(self, index: int, obj: T) -> None:
        super().insert(index, obj)

class IntList(TypList[int]):
    ...

il = IntList() 

il.append(1) # No error, as expected
il.append("a") # InputTypeError as expected

il.extend(iter([1, 2, 3])) # No error, as expected
il.extend(iter(["a", "b", "c"])) # No error, somewhat unexpected

print(il) # [1, 1, 2, 3, 'a', 'b', 'c']  <-- Ideally would only hold ints

>>> import typing
>>> from pytypes import type_util
>>> T = typing.TypeVar('T')
>>> class Foo(typing.Generic[T]):
...   pass
... 
>>> type_util.resolve_fw_decl(Foo)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'NoneType' object is not iterable