Allow varname to play with type annotation context (#32)

* Allow assignment with type annontation for varname

* Implement #33

* Fix for python3.6

* Implement expected behavior for ignore and caller for varname.varname

* Fix python3.6 for async.run in tests

* Add uniqueness check for qualname in ignore; Change _get_executing back to _get_frame to avoid expense of converting each frame into an executing object.

* Fix typo

* Put ignore list assertion into _check_qualname

Author: pwwang

README.rst

@@ -60,8 +60,7 @@ Features
 * Fetching variable names directly using ``nameof``
 * A value wrapper to store the variable name that a value is assigned to using ``Wrapper``
 * Detecting next immediate attribute name using ``will``
-* Shortcut for ``collections.namedtuple``
-* Injecting ``__varname__`` to objects
+* Injecting ``__varname__`` to classes
 * A ``debug`` function to print variables with their names and values.
 
 Credits
@@ -146,6 +145,23 @@ Retrieving the variable names from inside a function call/class instantiation
 
        k2 = k.copy() # k2.id == 'k2'
 
+* 
+  Multiple variables on Left-hand side
+
+  .. code-block:: python
+
+       # since v0.5.4
+
+       def func():
+           return varname(multi_vars=True)
+
+       a = func() # a == ('a', )
+       a, b = func() # (a, b) == ('a', 'b')
+       [a, b] = func() # (a, b) == ('a', 'b')
+
+       # hierarchy is also possible
+       a, (b, c) = func() # (a, b, c) == ('a', 'b', 'c')
+
 * 
   Some unusual use
 
@@ -256,41 +272,23 @@ Detecting next immediate attribute name
    awesome.permit() # AttributeError: Should do something with AwesomeClass object
    awesome.permit().do() == 'I am doing!'
 
-Shortcut for ``collections.namedtuple``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Injecting ``__varname__`` to classes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 .. code-block:: python
 
-   # instead of
-   from collections import namedtuple
-   Name = namedtuple('Name', ['first', 'last'])
+   from varname import inject_varname
 
-   # we can do:
-   from varname import namedtuple
-   Name = namedtuple(['first', 'last'])
-
-Injecting ``__varname__``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. code-block:: python
-
-   from varname import inject
-
-   class MyList(list):
+   @inject_varname
+   class Dict(dict):
        pass
 
-   a = inject(MyList())
-   b = inject(MyList())
-
+   a = Dict(a=1)
+   b = Dict(b=2)
    a.__varname__ == 'a'
    b.__varname__ == 'b'
-
-   a == b
-
-   # other methods not affected
-   a.append(1)
-   b.append(1)
-   a == b
+   a.update(b)
+   a == {'a':1, 'b':2}
 
 Debugging with ``debug``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

setup.py

@@ -1,3 +1,4 @@
+
 # -*- coding: utf-8 -*-
 
 # DO NOT EDIT THIS FILE!
@@ -9,6 +10,7 @@
 except ImportError:
     from distutils.core import setup
 
+
 import os.path
 
 readme = ''
@@ -18,16 +20,14 @@
     with open(readme_path, 'rb') as stream:
         readme = stream.read().decode('utf8')
 
+
 setup(
     long_description=readme,
     name='varname',
-    version='0.5.3',
+    version='0.5.5',
     description='Dark magics about variable names in python.',
     python_requires='==3.*,>=3.6.0',
-    project_urls={
-        "homepage": "https://github.com/pwwang/python-varname",
-        "repository": "https://github.com/pwwang/python-varname"
-    },
+    project_urls={"homepage": "https://github.com/pwwang/python-varname", "repository": "https://github.com/pwwang/python-varname"},
     author='pwwang',
     author_email='pwwang@pwwang.com',
     license='MIT',

tests/test_bytecode_nameof.py

@@ -5,6 +5,8 @@
 
 def nameof_both(*args):
     """Test both implementations at the same time"""
+    # No need caller=2 anymore, since internal calls from varname are ignored
+    # now by default
     result = nameof(*args, caller=2)
     if len(args) == 1:
         assert result == _bytecode_nameof(caller=2)
@@ -46,7 +48,6 @@ def test_nameof(self):
         c = nameof2(a, b)
         assert b == 'a'
         assert c == ('a', 'b')
-
         def func():
             return varname() + 'abc'
 

tests/test_varname.py

@@ -1,5 +1,4 @@
 import sys
-import unittest
 
 import pytest
 import subprocess
@@ -22,6 +21,12 @@ def getframe(_context):
     finally:
         sys._getframe = orig_getframe
 
+@pytest.fixture
+def enable_debug():
+    import varname as _varname
+    _varname.DEBUG = True
+    yield
+    _varname.DEBUG = False
 
 def test_function():
 
@@ -573,6 +578,42 @@ def test_debug(capsys):
     debug(a, b, merge=True)
     assert 'DEBUG: a=1, b=<object' in capsys.readouterr().out
 
+def test_internal_debug(capsys, enable_debug):
+    def my_decorator(f):
+        def wrapper():
+            return f()
+        return wrapper
+
+    @my_decorator
+    def foo1():
+        return foo2()
+
+    @my_decorator
+    def foo2():
+        return foo3()
+
+    @my_decorator
+    def foo3():
+        return varname(
+            caller=3,
+            ignore=[(
+                sys.modules[__name__],
+                "test_internal_debug.<locals>.my_decorator.<locals>.wrapper"
+            )]
+        )
+
+    x = foo1()
+    assert x == 'x'
+    msgs = capsys.readouterr().err.splitlines()
+    assert "Skipping frame from varname [In 'varname'" in msgs[0]
+    assert "Skipping (2 more to skip) [In 'foo3'" in msgs[1]
+    assert "Ignored [In 'wrapper'" in msgs[2]
+    assert "Skipping (1 more to skip) [In 'foo2'" in msgs[3]
+    assert "Ignored [In 'wrapper'" in msgs[4]
+    assert "Skipping (0 more to skip) [In 'foo1'" in msgs[5]
+    assert "Ignored [In 'wrapper'" in msgs[6]
+    assert "Gotcha! [In 'test_internal_debug'" in msgs[7]
+
 def test_inject_varname():
 
     @inject_varname
@@ -587,3 +628,96 @@ def __init__(self, a=1):
     f2 = Foo(2)
     assert f2.__varname__ == 'f2'
     assert f2.a == 2
+
+def test_type_anno_varname():
+
+    class Foo:
+        def __init__(self):
+            self.id = varname()
+
+    foo: Foo = Foo()
+    assert foo.id == 'foo'
+
+def test_generic_type_varname():
+    import typing
+    from typing import Generic, TypeVar
+
+    T = TypeVar("T")
+
+    class Foo(Generic[T]):
+        def __init__(self):
+            self.id = varname(ignore=[typing])
+    foo = Foo[int]()
+    assert foo.id == 'foo'
+
+    bar:Foo = Foo[str]()
+    assert bar.id == 'bar'
+
+    baz = Foo()
+    assert baz.id == 'baz'
+
+def test_async_varname():
+
+    import asyncio
+
+    def run_async(coro):
+        if sys.version_info < (3, 7):
+            loop = asyncio.get_event_loop()
+            return loop.run_until_complete(coro)
+        else:
+            return asyncio.run(coro)
+
+    async def func():
+        return varname(
+            ignore=[
+                asyncio,
+                (sys.modules[__name__], 'test_async_varname.<locals>.run_async')
+            ]
+        )
+
+    x = run_async(func())
+    assert x == 'x'
+
+    async def func():
+        # also works this way
+        return varname(
+            caller=2,
+            ignore=[asyncio, (sys.modules[__name__],
+                              'test_async_varname.<locals>.run_async')]
+        )
+
+    async def main():
+        return await func()
+
+    x = run_async(main())
+    assert x == 'x'
+
+def test_qualname_ignore_fail():
+    # not a list
+    def func():
+        return varname(ignore=sys)
+
+    with pytest.raises(AssertionError):
+        f = func()
+
+    # non-existing qualname
+    def func():
+        return varname(ignore=[(sys.modules[__name__], 'nosuchqualname')])
+
+    with pytest.raises(AssertionError):
+        f = func()
+
+    # non-unique qualname
+    def func():
+        return varname(ignore=[(sys.modules[__name__],
+                                'test_qualname_ignore_fail.<locals>.wrapper')])
+
+    def wrapper():
+        return func()
+
+    wrapper2 = wrapper
+    def wrapper():
+        return func()
+
+    with pytest.raises(AssertionError):
+        f = func()