handsdown-fork 0.1.0__py3-none-any.whl

handsdown/__init__.py

@@ -0,0 +1,4 @@
+"""Root of `handsdown` source code."""
+
+name = "handsdown"
+__all__ = ["name"]

handsdown/__main__.py

@@ -0,0 +1,5 @@
+"""Main module entrypoint."""
+from handsdown.main import main
+
+if __name__ == "__main__":
+    main()

handsdown/ast_parser/__init__.py

@@ -0,0 +1,28 @@
+"""
+# AST Parser.
+
+Collection of tools for analyzing AST and also rendering it back to a valid Python code.
+
+## Usage
+
+Use `handsdown.ast_parser.node_records.ModuleRecord` to parse the source code.
+
+### Examples
+
+```python
+from pathlib import Path
+
+from handsdown.utils.import_string import ImportString
+from handsdown.ast_parser.node_records import ModuleRecord
+
+source_path = Path("my_module.py")
+import_string = ImportString("my_module")
+module_record = ModuleRecord.create_from_source(source_path, import_string)
+module_record.build_children() # generate records for imports, classes, attributes
+and function in module
+
+function_record = module_record.function_records[0] # get the first function in module
+print(function_record.render(allow_multiline=True)) # print function definition
+print(function_record.return_type_hint.render()) # print function return type annotation
+```
+"""

handsdown/ast_parser/analyzers/__init__.py

@@ -0,0 +1 @@
+"""AST Analyzers."""

handsdown/ast_parser/analyzers/base_analyzer.py

@@ -0,0 +1,29 @@
+"""Base AST analyzer."""
+
+import handsdown.ast_parser.smart_ast as ast
+
+
+class BaseAnalyzer(ast.NodeVisitor):
+    """
+    Base AST analyzer.
+
+    Has lists for all objects for different analyzers.
+    """
+
+    def __init__(self) -> None:
+        self.related_names: list[str] = []
+
+    def get_docstring(self, node: ast.AST) -> str:
+        """
+        Get docstring from node.
+
+        Arguments:
+            node -- AST node.
+
+        Returns:
+            Docstring.
+
+        """
+        if isinstance(node, (ast.AsyncFunctionDef, ast.FunctionDef, ast.ClassDef, ast.Module)):
+            return ast.get_docstring(node, clean=False) or ""
+        return ""

handsdown/ast_parser/analyzers/class_analyzer.py

@@ -0,0 +1,176 @@
+"""AST analyzer for `ast.ClassDef` records."""
+from typing import Union
+
+import handsdown.ast_parser.smart_ast as ast
+from handsdown.ast_parser.analyzers.base_analyzer import BaseAnalyzer
+from handsdown.ast_parser.type_defs import ASTFunctionDef
+
+
+class ClassAnalyzer(BaseAnalyzer):
+    """AST analyzer for `ast.ClassDef` records."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.base_nodes: list[ast.expr] = []
+        self.decorator_nodes: list[ast.expr] = []
+        self.method_nodes: list[ASTFunctionDef] = []
+        self.attribute_nodes: list[Union[ast.Assign, ast.AnnAssign]] = []
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        """
+        Entrypoint for the analyzer.
+
+        Adds new `ast.expr` entry to `decorator_nodes` for each node
+        from `node.decorator_list`.
+        Adds new `ast.expr` entry to `base_nodes` for each node
+        from `node.bases`.
+        Visits each node from `node.body` list to parse methods.
+
+        Examples::
+
+            def my_func():
+                pass
+
+        Arguments:
+            node -- AST node.
+
+        """
+        for decorator_node in node.decorator_list:
+            self.decorator_nodes.append(decorator_node)
+        for base_node in node.bases:
+            self.base_nodes.append(base_node)
+        for element in node.body:
+            self.visit(element)
+
+    def _visit_FunctionDef(self, node: ASTFunctionDef) -> None:
+        name = node.name
+
+        docstring = self.get_docstring(node)
+
+        # skip private methods with no docstrings
+        if name.startswith("_") and not name.startswith("__") and not docstring:
+            return
+
+        # skip magic methods with no docstrings
+        if name.startswith("__") and name != "__init__" and not docstring:
+            return
+
+        self.method_nodes.append(node)
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        """
+        Parse info about class method statements.
+
+        Adds new `FunctionRecord` entry to `method_records`.
+
+        Examples:
+            ```python
+            class MyClass:
+                def my_method(self, arg):
+                    return arg
+            ```
+
+        Arguments:
+            node -- AST node.
+
+        """
+        self._visit_FunctionDef(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        """
+        Parse info about class asynchronous method statements.
+
+        Adds new `FunctionRecord` entry to `method_records`.
+
+        Examples:
+            ```python
+            class MyClass:
+                async def my_method(self, arg):
+                    return await arg
+            ```
+
+        Arguments:
+            node -- AST node.
+
+        """
+        self._visit_FunctionDef(node)
+
+    def visit_Assign(self, node: ast.Assign) -> None:
+        """
+        Parse info about class attribute statements.
+
+        Adds new `ast.Assign` entry to `attribute_nodes`.
+        Skips assignments to anything pther that a new variable.
+        Skips multiple assignments.
+        Skips assignments with names starting with `_`.
+
+        Examples:
+            ```python
+            class MyClass:
+                MY_MODULE_ATTR = "value"
+                my_attr = "value"
+
+                # these entries are skipped
+                _MY_MODULE_ATTR = "value"
+                multi_attr_1, multi_attr_2 = [1, 2]
+                my_object.name = "value"
+            ```
+
+        Arguments:
+            node -- AST node.
+
+        """
+        # skip multiple assignments
+        if len(node.targets) != 1:
+            return
+
+        # skip complex assignments
+        if not isinstance(node.targets[0], ast.Name):
+            return
+
+        name = node.targets[0].id
+
+        # skip private attributes
+        if name.startswith("_"):
+            return
+
+        self.attribute_nodes.append(node)
+
+    def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
+        """
+        Parse info about class annotated attribute statements.
+
+        Adds new `ast.AnnAssign` entry to `attribute_nodes`.
+        Skips assignments with names starting with `_`.
+
+        Examples:
+            ```python
+            class MyClass:
+                my_attr: int
+                my_value: int = 5
+            ```
+
+        Arguments:
+            node -- AST node.
+
+        """
+        # skip complex assignments
+        if not isinstance(node.target, ast.Name):
+            return
+
+        name = node.target.id
+
+        # skip private attributes
+        if name.startswith("_"):
+            return
+
+        self.attribute_nodes.append(node)
+
+    def generic_visit(self, node: ast.AST) -> None:
+        """
+        Do nothing for unknown `ast.AST` nodes.
+
+        Arguments:
+            node -- AST node.
+
+        """