Support PEP 561 typing (#6)

* Support PEP 561 typing

* Fix lint

---------

Co-authored-by: Jay Qi <jayqi@users.noreply.github.com>

Author: jayqi

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## v1.2.0 (2024-03-19)
+
+- Fixed the type signatures of `typenames` and `parse_type_tree` to reflect the typing of input type annotations, according to static type checkers.
+- Added [PEP 561 `py.typed` marker file](https://peps.python.org/pep-0561/#packaging-type-information) to indicate that the package supports type checking. 
+
 ## v1.1.0 (2024-03-08)
 
 - Changed `REMOVE_ALL_MODULES`'s regex pattern to also remove `<locals>` from rendered output. `<locals>` typically appears in a type's qualified name if the type was defined within the local scope of a function or class method. ([PR #4](https://github.com/jayqi/typenames/pull/4))

pyproject.toml

@@ -35,26 +35,22 @@ tests = ["pytest>=6"]
 "Changelog" = "https://jayqi.github.io/typenames/stable/changelog/"
 
 [tool.hatch.version]
-path = "typenames.py"
-
-[tool.hatch.build]
-exclude = ["inspect_types/", "docs/", "mkdocs.yml"]
-
+path = "typenames/__init__.py"
 
 ## DEFAULT ENVIRONMENT ##
 
 [tool.hatch.envs.default]
-dependencies = ["black", "ipython", "mypy", "reprexlite", "ruff"]
+dependencies = ["ipython", "mypy", "reprexlite", "ruff"]
 python = "3.10"
 path = ".venv"
 
 [tool.hatch.envs.default.scripts]
+format = ["ruff format"]
 lint = [
-  "black --check typenames.py tests.py",
-  "ruff check typenames.py tests.py",
+  "ruff format --check",
+  "ruff check",
 ]
-typecheck = ["mypy typenames.py --install-types --non-interactive"]
-
+typecheck = ["mypy --install-types --non-interactive"]
 
 ## TESTS ENVIRONMENT ##
 
@@ -67,10 +63,9 @@ template = "tests"
 python = ["3.8", "3.9", "3.10", "3.11", "3.12"]
 
 [tool.hatch.envs.tests.scripts]
-run = "pytest tests.py --cov=typenames --cov-report=term --cov-report=html --cov-report=xml"
+run = "pytest tests --cov=typenames --cov-report=term --cov-report=html --cov-report=xml"
 run-debug = "run --pdb"
 
-
 ## DOCS ENVIRONMENT ##
 
 [tool.hatch.envs.docs]
@@ -91,7 +86,6 @@ build = [
   "mkdocs build",
 ]
 
-
 ## INSPECT-TYPES ENVIRONMENT ##
 
 [tool.hatch.envs.inspect-types]
@@ -109,45 +103,30 @@ jupyter nbconvert inspect_types/_inspect_types.ipynb \
 --execute \
 --allow-errors"""
 
-
 ## TOOLS ##
 
-[tool.black]
-line-length = 99
-include = '\.pyi?$'
-exclude = '''
-/(
-    \.eggs
-  | \.git
-  | \.mypy_cache
-  | \.tox
-  | \.venv
-  | build
-  | dist
-  | tests/assets
-)/
-'''
-
 [tool.ruff]
 line-length = 99
+src = ["typenames", "tests"]
+
+[tool.ruff.lint]
 select = [
   "E", # Pyflakes
   "F", # Pycodestyle
   "I", # isort
 ]
-src = ["typenames.py", "tests.py"]
 unfixable = ["F"]
 
-[tool.ruff.isort]
+[tool.ruff.lint.isort]
 known-first-party = ["typenames"]
 force-sort-within-sections = true
 
 [tool.mypy]
-ignore_missing_imports = true
+files = ["typenames", "tests/typechecks.py"]
 
 [tool.pytest.ini_options]
 minversion = "6.0"
-testpaths = ["tests.py"]
+testpaths = ["tests"]
 
 [tool.coverage.run]
-source = ["typenames.py"]
+source = ["typenames"]

tests.py tests/test_typenames.pytests.py renamed to tests/test_typenames.py

@@ -50,19 +50,19 @@ class MyTypedDict(typing.TypedDict):
     (typing.List[int], "List[int]"),
     (typing.Tuple[str, int], "Tuple[str, int]"),
     (typing.Optional[int], "Optional[int]"),
-    (MyClass, "tests.MyClass"),
-    (OuterClass.InnerClass, "tests.OuterClass.InnerClass"),
-    (typing.List[MyClass], "List[tests.MyClass]"),
-    (typing.Optional[typing.List[MyClass]], "Optional[List[tests.MyClass]]"),
+    (MyClass, "test_typenames.MyClass"),
+    (OuterClass.InnerClass, "test_typenames.OuterClass.InnerClass"),
+    (typing.List[MyClass], "List[test_typenames.MyClass]"),
+    (typing.Optional[typing.List[MyClass]], "Optional[List[test_typenames.MyClass]]"),
     (typing.Union[float, int], "Union[float, int]"),
     (typing.Dict[str, int], "Dict[str, int]"),
     (typing.Any, "Any"),
     (typing.Dict[str, typing.Any], "Dict[str, Any]"),
     (typing.Callable[..., str], "Callable[..., str]"),
     (typing.Callable[[int], str], "Callable[[int], str]"),
     (typing.Callable[[int, float], str], "Callable[[int, float], str]"),
-    (MyGeneric[int], "tests.MyGeneric[int]"),
-    (MyEnum, "tests.MyEnum"),
+    (MyGeneric[int], "test_typenames.MyGeneric[int]"),
+    (MyEnum, "test_typenames.MyEnum"),
     (typing.List["int"], "List[int]"),
     (typing.List["typing.Any"], "List[Any]"),
     (typing.List["enum.Enum"], "List[enum.Enum]"),
@@ -71,7 +71,7 @@ class MyTypedDict(typing.TypedDict):
     # Python 3.8 adds typing.Literal, typing.Final, typing.TypedDict
     (typing.Literal["s", 0, MyEnum.MEMBER1], "Literal['s', 0, MyEnum.MEMBER1]"),
     (typing.Final[int], "Final[int]"),
-    (MyTypedDict, "tests.MyTypedDict"),
+    (MyTypedDict, "test_typenames.MyTypedDict"),
 ]
 
 
@@ -130,19 +130,19 @@ class FnScopeClass: ...
 
     # Default removal
     assert typenames(typing.Any) == "Any"
-    assert typenames(MyClass) == "tests.MyClass"
+    assert typenames(MyClass) == "test_typenames.MyClass"
     assert typenames(OtherModuleClass) == "other_module.OtherModuleClass"
-    assert typenames(FnScopeClass) == "tests.test_remove_modules.<locals>.FnScopeClass"
+    assert typenames(FnScopeClass) == "test_typenames.test_remove_modules.<locals>.FnScopeClass"
 
     # Override
-    config = TypenamesConfig(remove_modules=["tests"])
+    config = TypenamesConfig(remove_modules=["test_typenames"])
     assert typenames(typing.Any, config=config) == "typing.Any"
     assert typenames(MyClass, config=config) == "MyClass"
     assert typenames(OtherModuleClass, config=config) == "other_module.OtherModuleClass"
     assert typenames(FnScopeClass, config=config) == "test_remove_modules.<locals>.FnScopeClass"
 
     # Add to defaults
-    config = TypenamesConfig(remove_modules=DEFAULT_REMOVE_MODULES + ["tests"])
+    config = TypenamesConfig(remove_modules=DEFAULT_REMOVE_MODULES + ["test_typenames"])
     assert typenames(typing.Any, config=config) == "Any"
     assert typenames(MyClass, config=config) == "MyClass"
     assert typenames(OtherModuleClass, config=config) == "other_module.OtherModuleClass"
@@ -278,15 +278,19 @@ def test_node_repr():
 
 
 @pytest.mark.parametrize(
-    "case", is_union_special_form_cases, ids=[str(c[0]) for c in is_union_special_form_cases]
+    "case",
+    is_union_special_form_cases,
+    ids=[str(c[0]) for c in is_union_special_form_cases],
 )
 def test_is_union_special_form(case):
     """Test that is_union_special_form correctly identifies if using typing.Union."""
     assert is_union_special_form(case[0]) == case[1]
 
 
 @pytest.mark.parametrize(
-    "case", is_union_special_form_cases, ids=[str(c[0]) for c in is_union_special_form_cases]
+    "case",
+    is_union_special_form_cases,
+    ids=[str(c[0]) for c in is_union_special_form_cases],
 )
 def test_is_union_or_operator_for_typing_alias_cases(case):
     """Test that is_union_or_operator correctly returns False for all typing.Union test cases."""
@@ -305,14 +309,18 @@ def test_is_union_or_operator_for_typing_alias_cases(case):
     ]
 
     @pytest.mark.parametrize(
-        "case", is_union_or_operator_cases, ids=[str(c[0]) for c in is_union_or_operator_cases]
+        "case",
+        is_union_or_operator_cases,
+        ids=[str(c[0]) for c in is_union_or_operator_cases],
     )
     def test_is_union_or_operator(case):
         """Test that is_union_or_operator correctly identifies cases using | operator."""
         assert is_union_or_operator(case[0]) == case[1]
 
     @pytest.mark.parametrize(
-        "case", is_union_or_operator_cases, ids=[str(c[0]) for c in is_union_or_operator_cases]
+        "case",
+        is_union_or_operator_cases,
+        ids=[str(c[0]) for c in is_union_or_operator_cases],
     )
     def test_is_union_special_form_for_or_operator_cases(case):
         """Test that is_union_special_form correctly returns False for all | operator cases."""

tests/typechecks.py

@@ -0,0 +1,27 @@
+import typing
+
+from typenames import parse_type_tree, typenames
+
+typenames(int)
+# Unions
+typenames(str | int)
+typenames(typing.Union[str, int])
+typenames(typing.Optional[str])
+# Generics
+typenames(dict[str, int])
+typenames(typing.Dict[str, int])
+# Other special forms
+typenames(typing.Any)
+typenames(typing.Literal["foo"])
+
+parse_type_tree(int)
+# Unions
+parse_type_tree(str | int)
+parse_type_tree(typing.Union[str, int])
+parse_type_tree(typing.Optional[str])
+# Generics
+parse_type_tree(dict[str, int])
+parse_type_tree(typing.Dict[str, int])
+# Other special forms
+parse_type_tree(typing.Any)
+parse_type_tree(typing.Literal["foo"])