Add literal string support to includer and exclude filters

Author: lqhuang

.gitignore

@@ -10,6 +10,7 @@
 .pytest_cache
 .tox
 .vscode
+.venv*
 build
 dist
 docs/_build

src/attr/filters.py

@@ -13,6 +13,7 @@ def _split_what(what):
     """
     return (
         frozenset(cls for cls in what if isinstance(cls, type)),
+        frozenset(cls for cls in what if isinstance(cls, str)),
         frozenset(cls for cls in what if isinstance(cls, Attribute)),
     )
 
@@ -22,14 +23,19 @@ def include(*what):
     Include *what*.
 
     :param what: What to include.
-    :type what: `list` of `type` or `attrs.Attribute`\\ s
+    :type what: `list` of classes `type`, field names `str` or
+        `attrs.Attribute`\\ s
 
     :rtype: `callable`
     """
-    cls, attrs = _split_what(what)
+    cls, names, attrs = _split_what(what)
 
     def include_(attribute, value):
-        return value.__class__ in cls or attribute in attrs
+        return (
+            value.__class__ in cls
+            or attribute.name in names
+            or attribute in attrs
+        )
 
     return include_
 
@@ -39,13 +45,18 @@ def exclude(*what):
     Exclude *what*.
 
     :param what: What to exclude.
-    :type what: `list` of classes or `attrs.Attribute`\\ s.
+    :type what: `list` of classes `type`, field names `str` or
+        `attrs.Attribute`\\ s.
 
     :rtype: `callable`
     """
-    cls, attrs = _split_what(what)
+    cls, names, attrs = _split_what(what)
 
     def exclude_(attribute, value):
-        return value.__class__ not in cls and attribute not in attrs
+        return not (
+            value.__class__ in cls
+            or attribute.name in names
+            or attribute in attrs
+        )
 
     return exclude_

src/attr/filters.pyi

@@ -2,5 +2,5 @@ from typing import Any, Union
 
 from . import Attribute, _FilterType
 
-def include(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ...
-def exclude(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ...
+def include(*what: Union[type, str, Attribute[Any]]) -> _FilterType[Any]: ...
+def exclude(*what: Union[type, str, Attribute[Any]]) -> _FilterType[Any]: ...

tests/test_filters.py

@@ -30,8 +30,9 @@ def test_splits(self):
         """
         assert (
             frozenset((int, str)),
+            frozenset(("abcd", "123")),
             frozenset((fields(C).a,)),
-        ) == _split_what((str, fields(C).a, int))
+        ) == _split_what((str, "123", fields(C).a, int, "abcd"))
 
 
 class TestInclude:
@@ -46,6 +47,10 @@ class TestInclude:
             ((str,), "hello"),
             ((str, fields(C).a), 42),
             ((str, fields(C).b), "hello"),
+            (("a",), 42),
+            (("a",), "hello"),
+            (("a", str), 42),
+            (("a", fields(C).b), "hello"),
         ],
     )
     def test_allow(self, incl, value):
@@ -62,6 +67,10 @@ def test_allow(self, incl, value):
             ((int,), "hello"),
             ((str, fields(C).b), 42),
             ((int, fields(C).b), "hello"),
+            (("b",), 42),
+            (("b",), "hello"),
+            (("b", str), 42),
+            (("b", fields(C).b), "hello"),
         ],
     )
     def test_drop_class(self, incl, value):
@@ -84,6 +93,10 @@ class TestExclude:
             ((int,), "hello"),
             ((str, fields(C).b), 42),
             ((int, fields(C).b), "hello"),
+            (("b",), 42),
+            (("b",), "hello"),
+            (("b", str), 42),
+            (("b", fields(C).b), "hello"),
         ],
     )
     def test_allow(self, excl, value):
@@ -100,6 +113,10 @@ def test_allow(self, excl, value):
             ((str,), "hello"),
             ((str, fields(C).a), 42),
             ((str, fields(C).b), "hello"),
+            (("a",), 42),
+            (("a",), "hello"),
+            (("a", str), 42),
+            (("a", fields(C).b), "hello"),
         ],
     )
     def test_drop_class(self, excl, value):