Merge type-hints (in .pyi stub) into implementation

Test Plan:

- Ran all unit tests for inject library in Python 2.7/3.6 -> pass
  - Only ran autoparams test on 3.6 since that requires Python 3 type-hints.
- Ran all unit tests in my own project which uses these new changes -> pass

Author: Andrew William Borba

.travis.yml

@@ -3,8 +3,6 @@ matrix:
   include:
     - python: '2.7'
       env: EXTRA_ARGS='-I test_autoparams.py'
-    - python: '3.3'
-      env: EXTRA_ARGS='-I test_autoparams.py'
     - python: '3.4'
       env: EXTRA_ARGS='-I test_autoparams.py'
     - python: '3.5'

setup.py

@@ -1,5 +1,5 @@
 import sys
-from distutils.core import setup
+from setuptools import setup
 
 
 def read_description():
@@ -9,7 +9,7 @@ def read_description():
 
 setup(
     name='Inject',
-    version='3.5.1-dev',
+    version='3.5.1.dev0',
     url='https://github.com/ivankorobkov/python-inject',
     license='Apache License 2.0',
 
@@ -25,22 +25,19 @@ def read_description():
     data_files=[
         (
             'lib/python{}.{}/site-packages'.format(*sys.version_info[:2]),
-            ['src/inject.pyi']
-        ),
-        (
-            'shared/typehints/python{}.{}'.format(*sys.version_info[:2]),
-            ['src/inject.pyi']
+            ['src/inject.py']
         )
     ],
 
+    install_requires=['typing'],
+
     classifiers=[
         'Development Status :: 5 - Production/Stable',
         'Intended Audience :: Developers',
         'License :: OSI Approved :: Apache Software License',
         'Operating System :: OS Independent',
         'Programming Language :: Python',
         'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3.3',
         'Programming Language :: Python :: 3.4',
         'Programming Language :: Python :: 3.5',
         'Programming Language :: Python :: 3.6',

src/inject.py

@@ -83,16 +83,22 @@ def my_config(binder):
 import logging
 import sys
 import threading
-
+from typing import Optional, Type, Hashable, Callable, TypeVar, Union
 
 logger = logging.getLogger('inject')
 
 _INJECTOR = None  # Shared injector instance.
 _INJECTOR_LOCK = threading.RLock()  # Guards injector initialization.
 _BINDING_LOCK = threading.RLock()  # Guards runtime bindings.
 
+T = TypeVar('T')
+Binding = Union[Type[T], Hashable]
+Constructor = Provider = Callable[[], T]
+BinderCallable = Callable[['Binder'], None]
+
 
 def configure(config=None, bind_in_runtime=True):
+    # type: (Optional[BinderCallable], bool) -> Injector
     """Create an injector with a callable config or raise an exception when already configured."""
     global _INJECTOR
 
@@ -106,6 +112,7 @@ def configure(config=None, bind_in_runtime=True):
 
 
 def configure_once(config=None, bind_in_runtime=True):
+    # type: (Optional[BinderCallable], bool) -> Injector
     """Create an injector with a callable config if not present, otherwise, do nothing."""
     with _INJECTOR_LOCK:
         if _INJECTOR:
@@ -115,19 +122,22 @@ def configure_once(config=None, bind_in_runtime=True):
 
 
 def clear_and_configure(config=None, bind_in_runtime=True):
+    # type: (Optional[BinderCallable], bool) -> Injector
     """Clear an existing injector and create another one with a callable config."""
     with _INJECTOR_LOCK:
         clear()
         return configure(config, bind_in_runtime=bind_in_runtime)
 
 
 def is_configured():
+    # type: () -> bool
     """Return true if an injector is already configured."""
     with _INJECTOR_LOCK:
         return _INJECTOR is not None
 
 
 def clear():
+    # type: () -> None
     """Clear an existing injector if present."""
     global _INJECTOR
 
@@ -140,21 +150,25 @@ def clear():
 
 
 def instance(cls):
+    # type: (Binding) -> T
     """Inject an instance of a class."""
     return get_injector_or_die().get_instance(cls)
 
 
 def attr(cls):
+    # type: (Binding) -> T
     """Return a attribute injection (descriptor)."""
     return _AttributeInjection(cls)
 
 
 def param(name, cls=None):
+    # type: (str, Binding) -> Callable
     """Deprecated, use @inject.params. Return a decorator which injects an arg into a function."""
     return _ParameterInjection(name, cls)
 
 
 def params(**args_to_classes):
+    # type: (Binding) -> Callable
     """Return a decorator which injects args into a function.
 
     For example::
@@ -167,6 +181,7 @@ def sign_up(name, email, cache, db):
 
 
 def autoparams(*selected_args):
+    # type: (str) -> Callable
     """Return a decorator that will inject args into a function using type annotations, Python >= 3.5 only.
 
     For example::
@@ -201,11 +216,13 @@ def autoparams_decorator(func):
 
 
 def get_injector():
+    # type: () -> Injector
     """Return the current injector or None."""
     return _INJECTOR
 
 
 def get_injector_or_die():
+    # type: () -> Injector
     """Return the current injector or raise an InjectorException."""
     injector = _INJECTOR
     if not injector:
@@ -219,18 +236,21 @@ def __init__(self):
         self._bindings = {}
 
     def install(self, config):
+        # type: (BinderCallable) -> Binder
         """Install another callable configuration."""
         config(self)
         return self
 
     def bind(self, cls, instance):
+        # type: (Binding, T) -> Binder
         """Bind a class to an instance."""
         self._check_class(cls)
         self._bindings[cls] = lambda: instance
         logger.debug('Bound %s to an instance %s', cls, instance)
         return self
 
     def bind_to_constructor(self, cls, constructor):
+        # type: (Binding, Constructor) -> Binder
         """Bind a class to a callable singleton constructor."""
         self._check_class(cls)
         if constructor is None:
@@ -241,6 +261,7 @@ def bind_to_constructor(self, cls, constructor):
         return self
 
     def bind_to_provider(self, cls, provider):
+        # type: (Binding, Provider) -> Binder
         """Bind a class to a callable instance provider executed for each injection."""
         self._check_class(cls)
         if provider is None:
@@ -251,6 +272,7 @@ def bind_to_provider(self, cls, provider):
         return self
 
     def _check_class(self, cls):
+        # type: (Binding) -> None
         if cls is None:
             raise InjectorException('Binding key cannot be None')
 
@@ -269,6 +291,7 @@ def __init__(self, config=None, bind_in_runtime=True):
             self._bindings = {}
 
     def get_instance(self, cls):
+        # type: (Binding) -> T
         """Return an instance for a class."""
         binding = self._bindings.get(cls)
         if binding: