0.11.0 (#92)

* 🏷️ Overload types for nameof and argname

* 💥 Drop python <3.8  to prepare 0.11

* 🏷️ Fix return types of argname overload

* 🔖 0.11.0

Author: pwwang

.github/workflows/build.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-20.04  # lastest doesn't support python3.6
     strategy:
       matrix:
-        python-version: [3.6, 3.7, 3.8, 3.9, "3.10", 3.11-dev]
+        python-version: [3.8, 3.9, "3.10", 3.11-dev]
 
     steps:
       - uses: actions/checkout@v3

README.md

@@ -9,10 +9,13 @@ Dark magics about variable names in python
 [CHANGELOG][16] | [API][15] | [Playground][11] | :fire: [StackOverflow answer][20]
 
 ## Installation
+
 ```shell
 pip install -U varname
 ```
 
+Note if you use `python < 3.8`, install `varname < 0.11`
+
 ## Features
 
 - Core features:
@@ -90,6 +93,7 @@ Special thanks to [@HanyuuLu][2] to give up the name `varname` in pypi for this
     ```
 
     When there are intermediate frames:
+
     ```python
     def wrapped():
         return function()
@@ -102,6 +106,7 @@ Special thanks to [@HanyuuLu][2] to give up the name `varname` in pypi for this
     ```
 
     Or use `ignore` to ignore the wrapped frame:
+
     ```python
     def wrapped():
         return function()
@@ -113,6 +118,7 @@ Special thanks to [@HanyuuLu][2] to give up the name `varname` in pypi for this
     ```
 
     Calls from standard libraries are ignored by default:
+
     ```python
     import asyncio
 
@@ -124,6 +130,7 @@ Special thanks to [@HanyuuLu][2] to give up the name `varname` in pypi for this
 
     Use `strict` to control whether the call should be assigned to
     the variable directly:
+
     ```python
     def function(strict):
         return varname(strict=strict)
@@ -256,6 +263,7 @@ nameof(func.a.b, vars_only=False) # 'func.a.b'
 ```
 
 ### Detecting next immediate attribute name
+
 ```python
 from varname import will
 class AwesomeClass:
@@ -281,6 +289,7 @@ awesome.permit().do() == 'I am doing!'
 ```
 
 ### Fetching argument names/sources using `argname`
+
 ```python
 from varname import argname
 
@@ -339,6 +348,7 @@ mydict = values_to_dict(foo, bar)
 ```
 
 ### Debugging with `debug`
+
 ```python
 from varname.helpers import debug
 
@@ -362,6 +372,7 @@ debug(a+a, vars_only=True) # ImproperUseError
 ```
 
 ## Reliability and limitations
+
 `varname` is all depending on `executing` package to look for the node.
 The node `executing` detects is ensured to be the correct one (see [this][19]).
 
@@ -373,6 +384,7 @@ it at your own risk.
 For example:
 
 - This will not work with `pytest`:
+
   ```python
   a = 1
   assert nameof(a) == 'a' # pytest manipulated the ast here

README.raw.md

@@ -9,10 +9,13 @@ Dark magics about variable names in python
 [CHANGELOG][16] | [API][15] | [Playground][11] | :fire: [StackOverflow answer][20]
 
 ## Installation
+
 ```shell
 pip install -U varname
 ```
 
+Note if you use `python < 3.8`, install `varname < 0.11`
+
 ## Features
 
 - Core features:
@@ -90,6 +93,7 @@ Special thanks to [@HanyuuLu][2] to give up the name `varname` in pypi for this
     ```
 
     When there are intermediate frames:
+
     ```python
     def wrapped():
         return function()
@@ -102,6 +106,7 @@ Special thanks to [@HanyuuLu][2] to give up the name `varname` in pypi for this
     ```
 
     Or use `ignore` to ignore the wrapped frame:
+
     ```python
     def wrapped():
         return function()
@@ -113,6 +118,7 @@ Special thanks to [@HanyuuLu][2] to give up the name `varname` in pypi for this
     ```
 
     Calls from standard libraries are ignored by default:
+
     ```python
     import asyncio
 
@@ -124,6 +130,7 @@ Special thanks to [@HanyuuLu][2] to give up the name `varname` in pypi for this
 
     Use `strict` to control whether the call should be assigned to
     the variable directly:
+
     ```python
     def function(strict):
         return varname(strict=strict)
@@ -256,6 +263,7 @@ nameof(func.a.b, vars_only=False) # {_expr!r}
 ```
 
 ### Detecting next immediate attribute name
+
 ```python
 from varname import will
 class AwesomeClass:
@@ -281,6 +289,7 @@ awesome.permit().do() == 'I am doing!'
 ```
 
 ### Fetching argument names/sources using `argname`
+
 ```python
 from varname import argname
 
@@ -334,6 +343,7 @@ mydict = values_to_dict(foo, bar)
 ```
 
 ### Debugging with `debug`
+
 ```python
 from varname.helpers import debug
 
@@ -357,6 +367,7 @@ debug(a+a, vars_only=True) # {_exc}
 ```
 
 ## Reliability and limitations
+
 `varname` is all depending on `executing` package to look for the node.
 The node `executing` detects is ensured to be the correct one (see [this][19]).
 
@@ -368,6 +379,7 @@ it at your own risk.
 For example:
 
 - This will not work with `pytest`:
+
   ```python
   a = 1
   assert nameof(a) == 'a' # pytest manipulated the ast here

docs/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## v0.11.0
+
+- 📝 Update README for shields badges (#91)
+- 🏷️ Overload types for nameof and argname (#77)
+- 💥 Drop python <3.8  for v0.11
+     If you need support for python <3.8, please use varname <0.11
+
 ## v0.10.0
 
 - ✨ Support python 3.11

make_readme.py

@@ -44,10 +44,12 @@
 from io import StringIO
 from contextlib import redirect_stdout
 
+
 def printn(line):
     """Shortcut to print without new line"""
     print(line, end="")
 
+
 class CodeBlock:
     """The code block
 
@@ -73,70 +75,70 @@ class CodeBlock:
         stdout: The standard output of current code piece
             It will get overwritten by next code piece
     """
+
     def __init__(self, indent, backticks, lang, index, envs=None):
         self.indent = indent
         self.backticks = backticks
         self.lang = lang
-        self.codes = ''
+        self.codes = ""
         self.envs = envs or {}
-        self.produced = ''
+        self.produced = ""
         self.alive = True
         self.index = index
         self.piece = 0
-        self.stdout = ''
+        self.stdout = ""
 
     def compile_exec(self, code):
         """Compile and execute the code"""
         sourcefile = path.join(
             tempfile._get_default_tempdir(),
             f"codeblock_{self.index}_{self.piece}-"
-            f"{next(tempfile._get_candidate_names())}"
+            f"{next(tempfile._get_candidate_names())}",
         )
-        with open(sourcefile, 'w') as fsrc:
+        with open(sourcefile, "w") as fsrc:
             fsrc.write(code)
-        code = compile(code, sourcefile, mode='exec')
+        code = compile(code, sourcefile, mode="exec")
         sio = StringIO()
         with redirect_stdout(sio):
             exec(code, self.envs)
         self.stdout = sio.getvalue()
         self.piece += 1
 
-
     def feed(self, line):
         """Feed a single line to the code block, with line break"""
-        if self.lang not in ('python', 'python3'):
+        if self.lang not in ("python", "python3"):
             self.produced += line
 
         else:
-            if not line.strip(): # empty line
+            if not line.strip():  # empty line
                 self.codes += "\n"
                 self.produced += line
             else:
-                line = line[len(self.indent):]
+                line = line[len(self.indent) :]
                 if CodeBlock.should_compile(line):
                     if self.codes:
                         self.compile_exec(self.codes)
-                        self.codes = ''
+                        self.codes = ""
                     self.produced += self.indent + self.compile_line(line)
                 else:
                     self.codes += line
                     self.produced += self.indent + line
 
     def _compile_expr(self, line):
         """Compile {_expr}"""
-        varname = '_expr'
-        source = f'{varname} = {line}'
+        varname = "_expr"
+        source = f"{varname} = {line}"
         self.compile_exec(source)
-        code, comment = line.split('#', 1)
+        code, comment = line.split("#", 1)
         comment = comment.format(**self.envs)
-        return '#'.join((code, comment))
+        return "#".join((code, comment))
 
     def _compile_out(self, line):
         """Compile {_out}"""
         self.compile_exec(line)
-        code, comment = line.split('#', 1)
+        code, comment = line.split("#", 1)
         comment = comment.format(**self.envs, _out=self.stdout)
-        return '#'.join((code, comment))
+        return "#".join((code, comment))
 
     def _compile_exc(self, line, msg=False):
         """Compile {_exc} and {_exc_msg}"""
@@ -153,36 +155,36 @@ def _compile_exc(self, line, msg=False):
             source += " + ': ' + str(exc)"
         source += "\n"
         self.compile_exec(source)
-        code, comment = line.split('#', 1)
+        code, comment = line.split("#", 1)
         comment = comment.format(**self.envs)
-        return '#'.join((code, comment))
+        return "#".join((code, comment))
 
     def _compile_hidden(self, line):
         """Compile {_hidden}"""
         self.compile_exec(line)
-        return ''
+        return ""
 
     def _compile_var(self, line):
         """Compile variables"""
         self.compile_exec(line)
-        code, comment = line.split('#', 1)
+        code, comment = line.split("#", 1)
         comment = comment.format(**self.envs)
-        return '#'.join((code, comment))
+        return "#".join((code, comment))
 
     def compile_line(self, line):
         """Compile a single line"""
-        code, comment = line.split('#', 1)
+        code, comment = line.split("#", 1)
         if not code:
-            return '#' + comment.format(**self.envs, _out=self.stdout)
-        if '{_hidden}' in comment:
+            return "#" + comment.format(**self.envs, _out=self.stdout)
+        if "{_hidden}" in comment:
             return self._compile_hidden(line)
-        if re.search(r'\{_expr(?:!\w+)?\}', comment):
+        if re.search(r"\{_expr(?:!\w+)?\}", comment):
             return self._compile_expr(line)
-        if re.search(r'\{_out(?:!\w+)?\}', comment):
+        if re.search(r"\{_out(?:!\w+)?\}", comment):
             return self._compile_out(line)
-        if '{_exc}' in comment:
+        if "{_exc}" in comment:
             return self._compile_exc(line)
-        if '{_exc_msg}' in comment:
+        if "{_exc_msg}" in comment:
             return self._compile_exc(line, msg=True)
 
         return self._compile_var(line)
@@ -207,7 +209,9 @@ def try_open(cls, line, envs, index):
             return None
 
         indent, backticks, lang = (
-            matches.group(1), matches.group(2), matches.group(3),
+            matches.group(1),
+            matches.group(2),
+            matches.group(3),
         )
         return cls(indent, backticks, lang, index, envs)
 
@@ -218,19 +222,19 @@ def close(self, line):
             self.alive = False
             if self.codes:
                 self.compile_exec(self.codes)
-                self.codes = ''
+                self.codes = ""
             return True
 
         return False
 
     @staticmethod
     def should_compile(line):
         """Whether we should compile a line or treat it as a plain line"""
-        if '#' not in line:
+        if "#" not in line:
             return False
 
-        comment = line.split('#', 1)[1]
-        return re.search(r'\{[^}]+\}', comment)
+        comment = line.split("#", 1)[1]
+        return re.search(r"\{[^}]+\}", comment)
 
 
 def compile_readme(rawfile):
@@ -254,6 +258,7 @@ def compile_readme(rawfile):
                 if maybe_codeblock:
                     codeblock = maybe_codeblock
 
+
 if __name__ == "__main__":
     if len(sys.argv) < 2:
         print("Usage: make-readme.py README.raw.md > README.md")