Initial v3 support

Author: vemel

handsdown/ast_parser/analyzers/base_analyzer.py

@@ -1,7 +1,6 @@
 """
 Base AST analyzer.
 """
-from typing import List
 
 import handsdown.ast_parser.smart_ast as ast
 
@@ -14,7 +13,7 @@ class BaseAnalyzer(ast.NodeVisitor):
     """
 
     def __init__(self) -> None:
-        self.related_names: List[str] = []
+        self.related_names: list[str] = []
 
     def get_docstring(self, node: ast.AST) -> str:
         """

handsdown/ast_parser/analyzers/expression_analyzer.py

@@ -1,7 +1,6 @@
 """
 AST analyzer for `ast.expr` records.
 """
-from typing import Dict, List, Type
 
 import handsdown.ast_parser.smart_ast as ast
 from handsdown.ast_parser.analyzers.base_analyzer import BaseAnalyzer
@@ -20,13 +19,13 @@ class ExpressionAnalyzer(BaseAnalyzer):
     def __init__(self) -> None:
         super().__init__()
         self._logger = get_logger()
-        self.parts: List[Node] = []
+        self.parts: list[Node] = []
 
     # dummy value to replace unknown nodes and operators
     UNKNOWN = "..."
 
     # representation map for binary operators
-    BINOP_SYMBOLS: Dict[Type[ast.AST], str] = {
+    BINOP_SYMBOLS: dict[type[ast.AST], str] = {
         ast.Add: "+",
         ast.Sub: "-",
         ast.Mult: "*",
@@ -42,10 +41,10 @@ def __init__(self) -> None:
     }
 
     # representation map for boolean operators
-    BOOLOP_SYMBOLS: Dict[Type[ast.AST], str] = {ast.And: "and", ast.Or: "or"}
+    BOOLOP_SYMBOLS: dict[type[ast.AST], str] = {ast.And: "and", ast.Or: "or"}
 
     # representation map for comparison operators
-    CMPOP_SYMBOLS: Dict[Type[ast.AST], str] = {
+    CMPOP_SYMBOLS: dict[type[ast.AST], str] = {
         ast.Eq: "==",
         ast.NotEq: "!=",
         ast.Lt: "<",
@@ -59,14 +58,14 @@ def __init__(self) -> None:
     }
 
     # representation map for unary operators
-    UNARYOP_SYMBOLS: Dict[Type[ast.AST], str] = {
+    UNARYOP_SYMBOLS: dict[type[ast.AST], str] = {
         ast.Invert: "~",
         ast.Not: "not",
         ast.UAdd: "+",
         ast.USub: "-",
     }
 
-    def visit_Str(self, node: ast.Str) -> None:
+    def visit_Constant(self, node: ast.Constant) -> None:
         """
         Parse info from `ast.Str` node and put it to `parts`.
 
@@ -77,40 +76,11 @@ def visit_Str(self, node: ast.Str) -> None:
         Arguments:
             node -- AST node.
         """
-        value = node.s
+        value = node.value
         if isinstance(value, bytes):
             value = value.decode(ENCODING)
         self.parts.append(repr(value))
 
-    def visit_Bytes(self, node: ast.Bytes) -> None:
-        """
-        Parse info from `ast.Bytes` node and put it to `parts`.
-
-        Examples::
-
-            b"my_string"
-
-        Arguments:
-            node -- AST node.
-        """
-        value = node.s
-        self.parts.append(repr(value))
-
-    def visit_Num(self, node: ast.Num) -> None:
-        """
-        Parse info from `ast.Num` node and put it to `parts`.
-
-        Examples::
-
-            123
-            123.456
-
-        Arguments:
-            node -- AST node.
-        """
-        value = node.n
-        self.parts.append(repr(value))
-
     def visit_Name(self, node: ast.Name) -> None:
         """
         Parse info from `ast.Name` node and put it to `parts`.
@@ -125,20 +95,6 @@ def visit_Name(self, node: ast.Name) -> None:
         self.parts.append(node.id)
         self.related_names.append(node.id)
 
-    def visit_NameConstant(self, node: ast.NameConstant) -> None:
-        """
-        Parse info from `ast.NameConstant` node and put it to `parts`.
-
-        Examples::
-
-            None
-            True
-
-        Arguments:
-            node -- AST node.
-        """
-        self.parts.append(repr(node.value))
-
     def visit_Subscript(self, node: ast.Subscript) -> None:
         """
         Parse info from `ast.Subscript` node and put it to `parts`.
@@ -522,19 +478,6 @@ def visit_Index(self, node: ast.Index) -> None:
             return
         self.parts.append(node.value)  # type: ignore
 
-    def visit_Ellipsis(self, node: ast.ASTEllipsis) -> None:
-        """
-        Parse info from `ast.Ellipsis` node and put it to `parts`.
-
-        Examples::
-
-            ...
-
-        Arguments:
-            node -- AST node.
-        """
-        self.parts.append("...")
-
     def visit_Slice(self, node: ast.Slice) -> None:
         """
         Parse info from `ast.Slice` node and put it to `parts`.
@@ -572,8 +515,8 @@ def visit_JoinedStr(self, node: ast.JoinedStr) -> None:
         """
         self.parts.append("f'")
         for value in node.values:
-            if isinstance(value, (ast.Str, ast.Constant)):
-                str_value = value.s
+            if isinstance(value, ast.Constant):
+                str_value = value.value
                 if isinstance(str_value, bytes):
                     str_value = str_value.decode(ENCODING)
                 self.parts.append(str_value)
@@ -726,7 +669,7 @@ def visit_Yield(self, node: ast.Yield) -> None:
 
         Examples::
 
-            yield
+        Yield:
             yield value
 
         Arguments:

handsdown/ast_parser/analyzers/function_analyzer.py

@@ -1,7 +1,8 @@
 """
 AST analyzer for `ast.FunctionDef` records.
 """
-from typing import Any, List, Optional, Sequence
+from collections.abc import Sequence
+from typing import Any, List, Optional
 
 import handsdown.ast_parser.smart_ast as ast
 from handsdown.ast_parser.analyzers.base_analyzer import BaseAnalyzer

handsdown/ast_parser/analyzers/module_analyzer.py

@@ -1,7 +1,8 @@
 """
 AST analyzer for `ast.Module` records.
 """
-from typing import List, Union
+
+from typing import Union
 
 import handsdown.ast_parser.smart_ast as ast
 from handsdown.ast_parser.analyzers.base_analyzer import BaseAnalyzer
@@ -15,11 +16,11 @@ class ModuleAnalyzer(BaseAnalyzer):
 
     def __init__(self) -> None:
         super().__init__()
-        self.all_names: List[str] = []
-        self.import_nodes: List[ASTImport] = []
-        self.function_nodes: List[ASTFunctionDef] = []
-        self.attribute_nodes: List[Union[ast.Assign, ast.AnnAssign]] = []
-        self.class_nodes: List[ast.ClassDef] = []
+        self.all_names: list[str] = []
+        self.import_nodes: list[ASTImport] = []
+        self.function_nodes: list[ASTFunctionDef] = []
+        self.attribute_nodes: list[Union[ast.Assign, ast.AnnAssign]] = []
+        self.class_nodes: list[ast.ClassDef] = []
 
     def visit_Import(self, node: ast.Import) -> None:
         """
@@ -165,8 +166,8 @@ def visit_Assign(self, node: ast.Assign) -> None:
         # gather public names from `__all__` directive
         if name == "__all__" and isinstance(node.value, (ast.List, ast.Tuple, ast.Set)):
             for element in node.value.elts:
-                if isinstance(element, (ast.Str, ast.Constant)):
-                    value = element.s
+                if isinstance(element, ast.Constant):
+                    value = element.value
                     if isinstance(value, bytes):
                         value = value.decode("utf-8")
                     self.all_names.append(value)

handsdown/ast_parser/module_record_list.py

@@ -1,7 +1,8 @@
 """
 Aggregation of `ModuleRecord` objects.
 """
-from typing import Any, Dict, Iterator, List, Optional, Set
+from collections.abc import Iterator
+from typing import Any
 
 from handsdown.ast_parser.node_records.module_record import ModuleRecord
 from handsdown.utils.import_string import ImportString
@@ -15,10 +16,10 @@ class ModuleRecordList:
 
     def __init__(self) -> None:
         self._logger = get_logger()
-        self.data: List[ModuleRecord] = []
-        self.import_string_map: Dict[ImportString, Any] = {}
+        self.data: list[ModuleRecord] = []
+        self.import_string_map: dict[ImportString, Any] = {}
 
-    def find_module_record(self, import_string: ImportString) -> Optional[ModuleRecord]:
+    def find_module_record(self, import_string: ImportString) -> ModuleRecord | None:
         """
         Find `ModuleRecord` by it's import string.
 
@@ -40,7 +41,7 @@ def find_module_record(self, import_string: ImportString) -> Optional[ModuleReco
 
         return None
 
-    def get_package_names(self) -> Set[str]:
+    def get_package_names(self) -> set[str]:
         """
         Get top level import strings.
 

handsdown/ast_parser/node_records/argument_record.py

@@ -1,7 +1,6 @@
 """
 Wrapper for an `ast.arg` node.
 """
-from typing import List, Optional, Set
 
 import handsdown.ast_parser.smart_ast as ast
 from handsdown.ast_parser.node_records.expression_record import ExpressionRecord
@@ -25,19 +24,19 @@ def __init__(
         self,
         node: ast.arg,
         name: str,
-        type_hint: Optional[ast.expr] = None,
+        type_hint: ast.expr | None = None,
         prefix: str = "",
     ) -> None:
         super().__init__(node)
-        self._default: Optional[ExpressionRecord] = None
-        self.type_hint: Optional[ExpressionRecord] = None
+        self._default: ExpressionRecord | None = None
+        self.type_hint: ExpressionRecord | None = None
         if type_hint:
             self.type_hint = ExpressionRecord(type_hint)
         self.prefix = prefix
         self.name = name
 
     @property
-    def default(self) -> Optional[ExpressionRecord]:
+    def default(self) -> ExpressionRecord | None:
         """
         Default value of the argument.
 
@@ -69,7 +68,7 @@ def set_default(self, node: Node) -> None:
             self._default = ExpressionRecord(node)
 
     @property
-    def related_names(self) -> Set[str]:
+    def related_names(self) -> set[str]:
         """
         Set of related names.
         """
@@ -81,8 +80,8 @@ def related_names(self) -> Set[str]:
 
         return result
 
-    def _render_parts(self) -> List[RenderExpr]:
-        parts: List[RenderExpr] = []
+    def _render_parts(self) -> list[RenderExpr]:
+        parts: list[RenderExpr] = []
         if self.prefix:
             parts.append(self.prefix)
 

handsdown/ast_parser/node_records/attribute_record.py

@@ -1,7 +1,6 @@
 """
 Wrapper for an `ast.Assign` node of a module or class attribute.
 """
-from typing import List, Optional, Set, Union
 
 import handsdown.ast_parser.smart_ast as ast
 from handsdown.ast_parser.node_records.expression_record import ExpressionRecord
@@ -17,9 +16,9 @@ class AttributeRecord(NodeRecord):
         node -- AST node.
     """
 
-    def __init__(self, node: Union[ast.Assign, ast.AnnAssign]) -> None:
+    def __init__(self, node: ast.Assign | ast.AnnAssign) -> None:
         super().__init__(node)
-        self.default: Optional[ExpressionRecord] = None
+        self.default: ExpressionRecord | None = None
         first_target = node.targets[0] if isinstance(node, ast.Assign) else node.target
         assert isinstance(first_target, ast.Name)
         self.name = first_target.id
@@ -30,7 +29,7 @@ def __init__(self, node: Union[ast.Assign, ast.AnnAssign]) -> None:
         )
 
     @property
-    def related_names(self) -> Set[str]:
+    def related_names(self) -> set[str]:
         """
         Set of related names.
         """
@@ -40,8 +39,8 @@ def related_names(self) -> Set[str]:
 
         return result
 
-    def _render_parts(self) -> List[RenderExpr]:
-        parts: List[RenderExpr] = []
+    def _render_parts(self) -> list[RenderExpr]:
+        parts: list[RenderExpr] = []
         parts.append(self.name)
         if self.value is not None:
             parts.append(" = ")