Handsdown

https://vemel.github.io/handsdown/
Admin
Handsdown is a Python documentation generator that auto-generates Markdown documentation from Python...
Tokens:38,161
Snippets:622
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Method Example with Function Call

Source: https://vemel.github.io/handsdown/examples/google_docstrings

Shows a doctest example of setting up an environment and calling a function with keyword arguments.

```python
>>> setup_env()
>>> func_call(
...     first_name='test',
...     last_name='test',
... )
```

--------------------------------

### Install Handsdown using pip

Source: https://vemel.github.io/handsdown/handsdown

Install the Handsdown library using pip for project documentation generation.

```bash
pip install handsdown
```

--------------------------------

### PEP 257 Method Example with Doctest

Source: https://vemel.github.io/handsdown/examples/pep257_docstrings

Demonstrates a method with a PEP 257 docstring including a summary line, extended description, and doctest examples. Requires setup_env() and func_call().

```python
>>> print([i for i in
... example_generator(2)])
[
    'one',
    'two',
]
```

```python
>>> setup_env()
>>> func_call(
...     first_name='test',
...     last_name='test',
... )
```

```python
def method_example(self, text: str = "hello") -> int:
    """Summary line.

    Extended description of method.

    Examples:
        Examples should be written in doctest format, and should illustrate how to use the function.

    Args:
        text (str): Description of arg1
        *args: Description of args
        **kwargs: Description of kwargs

    Returns:
        int: Description of return value
    """
    ...
```

--------------------------------

### Python Module Documentation Example

Source: https://vemel.github.io/handsdown/handsdown

This snippet demonstrates how to structure a Python module with docstrings, type annotations, and comments to be processed by Handsdown. It includes examples of module docstrings, function docstrings with examples, class definitions with methods, and comment-style documented attributes.

```python
# main_example.py
"""
This is a module docstring. It will appear in documentation.

## Notes

You can use Markdown here to make it nicer. Also, in any docstring you
can put a global object import string in backticks, like `other_module.OtherClass`,
and it will be transformed to a link.
"""
from typing import Text, TYPE_CHECKING

from my_project.other_module import BaseClass  # pylint: disable=import-error

if TYPE_CHECKING:
    from my_project.type_defs import StuffCallable  # pylint: disable=import-error

# This is a comment-style documented global variable, so it is added to
# `main_example` module attributes with this comment as a documentation for it
# FIXME: FIXME and TODO comments are igonred
MODULE_NAME = "My Module"

# Private args never appear in docs
_PRIVATE_ATTR = "Private attr"


def hello(name: Text) -> Text:
    """
    This is module function and it is added to documentation even if it does
    not have a docstring. Function signature will be also generated respecting
    regular and comment-style type annotations. Let's use PEP 257 format here.

    Examples::

        # Google-style code block here, but we could use Markdown code block as well
        >>> hello('John')
        'Hello, John!'

        >>> hello('')
        'Hello!'

    Arguments:
        name -- Name of the person to greet.

    Returns:
        A greeting. No need to put types here if you use type annotations.
    """
    if not name:
        return "Hello!"

    return f"Hello, {name}!"


class MyClass(BaseClass):
    """
    MyClass documentation here.

    .. note:: This time we use RST docstrings format.
    """

    # This is a comment-style documented class attribute, so it is added to
    # `main_example.MyClass` attributes with this comment as a documentation for it.
    STUFF_COUNT = 3

    @classmethod
    def do_something(cls, stuff):
        # type: (StuffCallable) -> bool
        """
        This is a public method that uses comment-style type annotations. If decorators
        or types from annotations are from your project, links to them will be added
        to `See also` section. Since this function depends on `STUFF_COUNT`, we can add
        it to a docstring in backticks and it will be transformed to a link.

        .. code-block:: python

            # usage example
            def my_stuff(amount):
                return amount > 5

            MyClass.do_something(my_stuff)  # False

        .. versionadded:: 1.3
        .. deprecated:: 1.8
        .. versionchanged:: 1.4
            All these directives are added to `Notes` section and formatted in Sphinx-style.

        :param stuff: Function do execute.
        :returns: `stuff` result.
        """
        return stuff(cls.STUFF_COUNT)

    def __bool__(self):
        # type: () -> bool
        """
        Magic methods are added to docs only if they have docstrings.

        :returns: True if `STUFF_COUNT` is not zero
        """
        return self.STUFF_COUNT

```

--------------------------------

### Class Definition Example

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/class_analyzer

This example shows a basic class definition with a function.

```python
def my_func():
    pass

```

--------------------------------

### Code Example for Reference

Source: https://vemel.github.io/handsdown/examples/sphinx_docstrings

A simple Python dictionary and print statement used as a code example within a docstring.

```python
data = {
    'key': 'value',
}

print(data)

```

--------------------------------

### Class Example Signature

Source: https://vemel.github.io/handsdown/examples/google_docstrings

Demonstrates the basic signature of a class intended for Google-style docstrings.

```python
class ClassExample:
    ...
```

--------------------------------

### Function Example Usage

Source: https://vemel.github.io/handsdown/examples/google_docstrings

Demonstrates how to call a Python function with a dictionary, None, and prints the result.

```python
result = function_example(
    {
        'key': 'value',
    },
    None,
)

print result
```

--------------------------------

### Hello Function Examples

Source: https://vemel.github.io/handsdown/examples/main_example

Illustrates the usage of the 'hello' function with different inputs, showing expected outputs for a name and an empty string.

```python
# Google-style code block here, but we could use Markdown code block as well
>>> hello('John')
'Hello, John!'

>>> hello('')
'Hello!'
```

--------------------------------

### Class Method Example

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/class_analyzer

Provides an example of defining a regular method within a class. This method can be called on instances of the class.

```python
class MyClass:
    def my_method(self, arg):
        return arg

```

--------------------------------

### Method Example with Doctest

Source: https://vemel.github.io/handsdown/examples/google_docstrings

Illustrates using a generator within a doctest for a method, showing expected output.

```python
>>> print([i for i in
... example_generator(2)])
[
    'one',
    'two',
]
```

--------------------------------

### PEP 257 Function Example

Source: https://vemel.github.io/handsdown/examples/pep257_docstrings

Example of a function with a PEP 257 docstring specifying arguments with default values.

```python
def function_example(real=0.0, imag=0.0):
    """Form a complex number.

    Args:
        real (float): the real part (default 0.0).
        imag (float): the imaginary part (default 0.0).
    """
    ...
```

--------------------------------

### Function Example Signature

Source: https://vemel.github.io/handsdown/examples/google_docstrings

Provides the signature for a Python function with positional and optional arguments.

```python
def function_example(arg1, arg2, arg3=None):
    ...
```

--------------------------------

### main

Source: https://vemel.github.io/handsdown/handsdown/main

The primary entrypoint for the handsdown Command Line Interface (CLI). This function is expected to be the starting point when handsdown is executed from the command line.

```APIDOC
## main

### Description
Main entrypoint for CLI.

### Signature
```
def main() -> None:
    ...

```
```

--------------------------------

### Class Method do_something Usage Example

Source: https://vemel.github.io/handsdown/examples/main_example

Demonstrates the usage of the MyClass.do_something class method with a sample function 'my_stuff'. Shows how to pass a callable as an argument.

```python
# usage example
def my_stuff(amount):
    return amount > 5

MyClass.do_something(my_stuff)  # False
```

--------------------------------

### Class Annotated Attribute Example

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/class_analyzer

Demonstrates how to define class attributes with type annotations. Assignments with names starting with '_' are skipped.

```python
class MyClass:
    my_attr: int
    my_value: int = 5

```

--------------------------------

### Class Attribute Assignment Example

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/class_analyzer

Shows class attribute assignments. It skips assignments to non-variables, multiple assignments, and names starting with '_'.

```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"

```

--------------------------------

### Mathematical Notes Example

Source: https://vemel.github.io/handsdown/examples/sphinx_docstrings

Illustrates mathematical formulas within Sphinx docstrings using reStructuredText.

```text
(a + b)^2 = a^2 + 2ab + b^2

(a - b)^2 = a^2 - 2ab + b^2

```

--------------------------------

### ImportString().startswith

Source: https://vemel.github.io/handsdown/handsdown/utils/import_string

Checks if the import string starts with a given import string. Returns True if it is a child.

```APIDOC
## ImportString().startswith

### Description
Check if it starts with `import_string`.

### Returns
True if it is a child.

### Signature
```python
def startswith(self: _R, import_string: _R) -> bool:
    ...
```
```

--------------------------------

### MyValue Class Signature

Source: https://vemel.github.io/handsdown/examples/pyi_typed

Defines the signature for the MyValue class. This is a stub file example.

```python
class MyValue:
    ...
```

--------------------------------

### Synchronous Function Definition Example

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/function_analyzer

Example of a standard synchronous function definition. This snippet shows a basic function that returns a result.

```python
def my_func():
    return result
```

--------------------------------

### Class Signature for MyClass

Source: https://vemel.github.io/handsdown/examples/main_example

Shows the class definition for MyClass, inheriting from BaseClass. This is a basic structural example.

```python
class MyClass(BaseClass):
    ...
```

--------------------------------

### Async Function Definition Example

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/function_analyzer

Example of an asynchronous function definition. This snippet demonstrates the basic structure of an async function that performs an awaited operation.

```python
async def my_func():
    return await result
```

--------------------------------

### Class Asynchronous Method Example

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/class_analyzer

Illustrates defining an asynchronous method within a class. This method can perform awaitable operations.

```python
class MyClass:
    async def my_method(self, arg):
        return await arg

```

--------------------------------

### Get Source Code URL Method

Source: https://vemel.github.io/handsdown/handsdown/cli_parser

Retrieves the URL to the source code for the current object. Returns the URL as a string.

```python
def get_source_code_url(self) -> str:
    ...

```

--------------------------------

### Getting import string parts with parts

Source: https://vemel.github.io/handsdown/handsdown/utils/import_string

Splits the import string by dots and returns a list of its components.

```python
ImportString("my_module.MyClass")
["my_module", "MyClass"]

ImportString("")
[]
```

```python
@property
def parts(self) -> List[str]:
    ... 
```

--------------------------------

### Define MyValue Class

Source: https://vemel.github.io/handsdown/examples/typed

A simple class definition for MyValue. Used as a type hint in other examples.

```python
class MyValue:
    ...

```

--------------------------------

### ImportRecord.match

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/import_record

Checks if a given name matches or starts with a local name imported by this record.

```APIDOC
## Method match

### Description
Check if `name` matches or starts with a local name.

### Arguments
* `name` (str) - The name to check against the imported names.

### Returns
True if the name is imported or is a child of an imported name, False otherwise.

### Examples
```python
# Assuming import_record is an instance of ImportRecord
# For example, initialized with 'from my_module import Name as LocalName'

import_record.match('LocalName')
# Expected output: True

import_record.match('LocalName.child')
# Expected output: True

import_record.match('OtherName')
# Expected output: False

import_record.match('LocalNameOther')
# Expected output: False
```

### Signature
```python
def match(self, name: str) -> Optional[ImportString]:
    ...
```

### See Also
* ImportString
```

--------------------------------

### Getting the parent import string with parent

Source: https://vemel.github.io/handsdown/handsdown/utils/import_string

Returns the immediate parent import string of the current instance.

```python
@property
def parent(self: _R) -> _R:
    ... 
```

--------------------------------

### func Function Signature

Source: https://vemel.github.io/handsdown/examples/pyi_typed

Defines the signature for the func function, including a default argument for MyValue. This is a stub file example.

```python
def func(_list, _my_value_cls=MyValue, **_kwargs):
    ...
```

--------------------------------

### MyValue Class Definition

Source: https://vemel.github.io/handsdown/examples/comment_typed

Defines a basic class `MyValue` with an initializer. This serves as a type hint target in other examples.

```python
class MyValue:
    def __init__(self, *args, **kwargs) -> None:
        ...
```

--------------------------------

### func_an Function Signature

Source: https://vemel.github.io/handsdown/examples/pyi_typed

Defines the signature for the func_an function, including a default argument for MyValue. This is a stub file example.

```python
def func_an(_list, _my_value_cls=MyValue, **_kwargs):
    ...
```

--------------------------------

### ImportRecord.match Method Signature

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/import_record

Signature for the match method, which checks if a name matches or starts with a local name.

```python
def match(self, name: str) -> Optional[ImportString]:
    ...
```

--------------------------------

### Initialize and Generate Docs with Handsdown

Source: https://vemel.github.io/handsdown/handsdown

Set up the Handsdown generator with input and output paths, specify source files using PathFinder, and generate all documentation or for a specific file.

```python
from handsdown.generator import Generator
from handsdown.utils.path import PathFinder
from pathlib import Path

repo_path = Path.cwd()

path_finder = PathFinder(repo_path, "**/*.py")
path_finder.exclude("tests/*", "build/*")

handsdown = Generator(
    input_path=repo_path,
    output_path=repo_path / 'output',
    source_paths=path_finder.glob("**/*.py")
)

handsdown.generate_docs()
handsdown.generate_doc(repo_path / 'my_module' / 'source.py')
handsdown.generate_index()
```

--------------------------------

### Checking if import string starts with another with startswith

Source: https://vemel.github.io/handsdown/handsdown/utils/import_string

Verifies if the current import string begins with a specified import string. Returns True if it does.

```python
def startswith(self: _R, import_string: _R) -> bool: ... 
```

--------------------------------

### NodeRecord.line_number Property (Getter)

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/node_record

Retrieves the starting line number of the node in the source code. Returns a 1-based index.

```python
@property
def line_number(self) -> int:
    ...
```

--------------------------------

### Basic PathFinder Usage

Source: https://vemel.github.io/handsdown/handsdown/utils/path_finder

Demonstrates initializing PathFinder and finding all .txt files in the current working directory.

```python
path_finder = PathFinder(Path.cwd())
list(path_finder.glob('*.txt'))
['my_new.txt', 'my.txt', 'new.txt']
```

--------------------------------

### Initialize and Write MDDocument

Source: https://vemel.github.io/handsdown/handsdown/md_document

Demonstrates initializing MDDocument, appending content, setting the title, and writing to a file. Also shows how to read the generated file content.

```python
md_doc = MDDocument(path=Path('output.md'))
md_doc.append('## New section')
md_doc.append('some content')
md_doc.title = 'My doc'
md_doc.write()

# output is indented for readability
Path('output.md').read_text()
'''# My doc

- [My doc](#my-doc)
  - [New section](#new-section)

## New section

some content
'''
```

```python
with MDDocument(path=Path('output.md')) as md_document:
    md_document.title = 'My doc'
    md_doc.append_title('New section', level=2)
    md_doc.append('New line')
```

--------------------------------

### Loader Initialization

Source: https://vemel.github.io/handsdown/handsdown/loader

Initializes the Loader with project root path, documentation output path, and optional file encoding.

```APIDOC
## Loader

### Description
Loader for Python source code.

### Arguments
* `root_path` (Path) - Root path of the project.
* `output_path` (Path) - Docs output path.
* `encoding` (str) - File encoding. Defaults to ENCODING.

### Signature
```python
class Loader:
    def __init__(
        self, root_path: Path, output_path: Path, encoding: str = ENCODING
    ) -> None:
        ...
```

### See also
* ENCODING
```

--------------------------------

### Generate Documentation from Command Line

Source: https://vemel.github.io/handsdown/handsdown

These commands show how to use the Handsdown CLI to generate Markdown documentation for a Python project. You can specify output directories, include/exclude patterns, and external repository URLs.

```bash
cd ~/my/project

# build documentation *.md* files in docs/* directory
handsdown

# or provide custom output directory: output_dir/*
handsdown -o output_dir

# generate docs only for my_module, but exclude migrations
handsdown my_module --exclude 'build/*' 'tests/*' 'test/*' '*/__pycache__/*' '.*/*' 'my_module/migrations'

# generate documentation for deployment
handsdown --external `git config --get remote.origin.url` -n ProjectName
```

--------------------------------

### PEP 257 Class Definition

Source: https://vemel.github.io/handsdown/examples/pep257_docstrings

Example of a class definition following PEP 257 docstring conventions. Attributes are documented using a standard format.

```python
class ClassExample:
    """PEP257-style class example

    Attributes:
        attr1 (str): Description of attr1.
        attr2 (str): Description of attr2.
    """
    ...
```

--------------------------------

### ClassRecord get_public_methods Method

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/class_record

Retrieves a list of public methods for the class. It skips private methods (starting with '_') and magic methods (starting with '__') unless they have a docstring. The __init__ method is always excluded.

```python
def get_public_methods(self) -> List[FunctionRecord]:
    ...
```

--------------------------------

### ArgumentRecord().related_names

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/argument_record

Gets the set of related names associated with the argument.

```APIDOC
## ArgumentRecord().related_names

### Description
Set of related names.

### Signature
```python
@property
def related_names(self) -> Set[str]:
    ...
```
```

--------------------------------

### NodeRecord().line_number (getter)

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/node_record

Gets the line number of the node in the source code.

```APIDOC
## NodeRecord().line_number

### Description
Return node line number in source. This property provides the starting line number of the node within the source file.

### Returns
A line number starting with 1.

### Signature
```python
@property
def line_number(self) -> int:
    ... 
```
```

--------------------------------

### Get Top-Level Package Names

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/module_record_list

Retrieves a set of top-level import strings. This method returns a set of strings representing package names.

```python
def get_package_names(self) -> Set[str]:
    ...
```

--------------------------------

### Get Import String

Source: https://vemel.github.io/handsdown/handsdown/loader

Generates the Python import string for a source file path relative to the loader's root path. Handles both regular modules and __init__.py files.

```python
loader = Loader(root_path=Path("/root"), ...)
loader.get_import_string('/root/my_module/test.py')
'my_module.test'
```

```python
loader.get_import_string('/root/my_module/__init__.py')
'my_module'
```

--------------------------------

### Initialize Loader

Source: https://vemel.github.io/handsdown/handsdown/loader

Instantiate the Loader with the project's root path. This sets up the loader to find and import modules within the specified directory.

```python
loader = Loader(Path('path/to/my_module/'))
my_module_utils = loader.import_module('my_module.utils')
```

--------------------------------

### Analyze Module Async Function Definitions

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/module_analyzer

Parses information about module `async def ...` statements. Adds nodes to `function_nodes`, skipping those with names starting with '_'.

```python
async def my_func(arg1):
    return await arg1
```

--------------------------------

### api

Source: https://vemel.github.io/handsdown/handsdown/main

CLI entrypoint for handsdown. This function likely handles command-line arguments and orchestrates the application's behavior.

```APIDOC
## api

### Description
CLI entrypoint for handsdown. This function likely handles command-line arguments and orchestrates the application's behavior.

### Signature
```
def api(args: CLINamespace) -> None:
    ...

```

### See also
* CLINamespace
```

--------------------------------

### PathFinder with Include Pattern

Source: https://vemel.github.io/handsdown/handsdown/utils/path_finder

Shows how to use the 'include' method to filter files matching a specific pattern before globbing.

```python
list(path_finder.include('my*').glob('*.txt'))
['my_new.txt', 'my.txt']
```

--------------------------------

### Aasdas Class Signature

Source: https://vemel.github.io/handsdown/examples/pyi_typed

Defines the signature for the Aasdas class. This is a stub file example.

```python
class Aasdas:
    ...
```

--------------------------------

### BaseGenerator

Source: https://vemel.github.io/handsdown/handsdown/generators/base

Initializes the BaseGenerator with project and source path configurations. It sets up various parameters for documentation generation, including paths, processors, loaders, and error handling.

```APIDOC
## BaseGenerator

### Description
Initializes the BaseGenerator with project and source path configurations. It sets up various parameters for documentation generation, including paths, processors, loaders, and error handling.

### Arguments
* `project_name` (Optional[str]) - Name of the project.
* `input_path` (Path) - Path to repo to generate docs.
* `output_path` (Path) - Path to folder with auto-generated docs to output.
* `source_paths` (Iterable[Path]) - List of paths to source files for generation.
* `docstring_processor` (Optional[BaseDocstringProcessor]) - Docstring converter to Markdown.
* `loader` (Optional[Loader]) - Loader for python modules.
* `raise_errors` (bool) - Raise `LoaderError` instead of silencing in. Defaults to `False`.
* `source_code_url` (Optional[str]) - URL to source files to use instead of relative paths, useful for GitHub Pages.
* `source_code_path` (Optional[Path]) - Path to local source code.
* `toc_depth` (int) - Maximum depth of child modules ToC. Defaults to `1`.
* `encoding` (str) - File encoding. Defaults to `ENCODING`.
```

--------------------------------

### Get Output Path

Source: https://vemel.github.io/handsdown/handsdown/loader

Internal method to determine the output Markdown file path for a given source code file path. It ensures the path is correctly formatted relative to the loader's output directory.

```python
def _get_output_path(self, source_path: Path) -> Path:
    ... 
```

--------------------------------

### MDDocument().title

Source: https://vemel.github.io/handsdown/handsdown/md_document

Gets the title of the MDDocument. If no title is set, it returns an empty string.

```APIDOC
## MDDocument().title

### Description
MDDocument title or an empty string.

### Signature
```python
@property
def title(self) -> str:
    ...
```
```

--------------------------------

### Generate Documentation as a Module

Source: https://vemel.github.io/handsdown/handsdown

This snippet shows how to use the Handsdown library programmatically within a Python script. It imports the necessary Generator and PathFinder classes.

```python
from handsdown.generator import Generator
from handsdown.utils.path_finder import PathFinder
```

--------------------------------

### ArgumentRecord Class Initialization

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/argument_record

Initializes an ArgumentRecord with the AST node, name, optional type hint, and an optional prefix.

```python
class ArgumentRecord(NodeRecord):
    def __init__(
        self,
        node: ast.arg,
        name: str,
        type_hint: Optional[ast.expr] = None,
        prefix: str = "",
    ) -> None:
        ..."
```

--------------------------------

### Initialize Markdown Header

Source: https://vemel.github.io/handsdown/handsdown/utils/markdown

Use this to create a Markdown header object. Specify the title, level (1-6), and an optional anchor link.

```python
class Header:
    def __init__(self, title: str, level: int, anchor: str) -> None:
        ...
```

--------------------------------

### PathFinder().mkdir

Source: https://vemel.github.io/handsdown/handsdown/utils/path_finder

Creates directories up to the root path if they do not already exist. Optionally, it can force the creation by deleting existing parent directories if they are not directories.

```APIDOC
## PathFinder().mkdir

### Description
Create directories up to `root` if they do not exist.

### Arguments
* `force` - Delete existing parent if it is not a directory.

### Raises
* `PathFinderError` - If any existing parent is not a directory and not in `force` mode.

### Signature
```python
def mkdir(self, force: bool = False) -> None:
    ...
```
```

--------------------------------

### Trim Empty Lines from Text

Source: https://vemel.github.io/handsdown/handsdown/utils/indent_trimmer

Removes blank lines from the start and end of a multi-line string.

```python
text = '\n  \n test\ntest2\n \n '
IndentTrimmer.trim_empty_lines(text)
' test\ntest2'
```

--------------------------------

### FunctionRecord Class Initialization

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/function_record

Initializes a FunctionRecord instance. Requires an AST node and a boolean indicating if it's a method.

```python
class FunctionRecord(NodeRecord):
    def __init__(self, node: ASTFunctionDef, is_method: bool) -> None:
        ..."""
```

--------------------------------

### MDDocument().subtitle

Source: https://vemel.github.io/handsdown/handsdown/md_document

Gets or sets the subtitle of the MDDocument. If no subtitle is set, it returns an empty string.

```APIDOC
## MDDocument().subtitle

### Description
MDDocument subtitle or an empty string.

### Signature
```python
@property
def subtitle(self) -> str:
    ...
```

## MDDocument().subtitle (setter)

### Signature
```python
@subtitle.setter
def subtitle(self, subtitle: str) -> None:
    ...
```
```

--------------------------------

### JinjaManager().render

Source: https://vemel.github.io/handsdown/handsdown/jinja_manager

Renders a Jinja2 template from a given file path with provided keyword arguments.

```APIDOC
## JinjaManager().render

### Description
Renders a Jinja2 template.

### Method
Instance Method

### Parameters
#### Arguments
* `template_path` (Path) - The path to the Jinja2 template file.
* `**kwargs` (Any) - Additional keyword arguments to pass to the template context.

### Signature
```python
def render(self, template_path: Path, **kwargs: Any) -> str:
    ...
```
```

--------------------------------

### Get Line Indent Length

Source: https://vemel.github.io/handsdown/handsdown/utils/indent_trimmer

Use this to determine the number of leading spaces on a given line.

```python
IndentTrimmer.get_line_indent('   test')
3

IndentTrimmer.get_line_indent('test')
0
```

--------------------------------

### BaseGenerator.get_external_configs_templates Method Signature

Source: https://vemel.github.io/handsdown/handsdown/generators/base

Returns a tuple containing pairs of template paths and their corresponding project paths for external configurations.

```python
def get_external_configs_templates(self) -> Tuple[Tuple[Path, Path], ...]:
    ... 

```

--------------------------------

### Getting the last part of the import string with name

Source: https://vemel.github.io/handsdown/handsdown/utils/import_string

Retrieves the final component of the import string.

```python
@property
def name(self) -> str:
    ... 
```

--------------------------------

### Getting String Value with __str__

Source: https://vemel.github.io/handsdown/handsdown/utils/import_string

Retrieves the original import string value from an ImportString instance.

```python
str(ImportString("my_module"))
"my_module"
```

--------------------------------

### BaseGenerator.generate_docs Method Signature

Source: https://vemel.github.io/handsdown/handsdown/generators/base

Generates documentation files for all modules within the project.

```python
def generate_docs(self) -> None:
    ... 

```

--------------------------------

### Main Function Signature

Source: https://vemel.github.io/handsdown/handsdown/main

Signature for the main entrypoint function of the Handsdown CLI.

```python
def main() -> None:
    ...
```

--------------------------------

### ClassRecord().init_method

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/class_record

Provides access to the `__init__` method of the class, if it exists.

```APIDOC
## ClassRecord().init_method

### Description
Get the `__init__` method.

### Signature
```python
@property
def init_method(self) -> Optional[FunctionRecord]:
    ...
```

### See also
* FunctionRecord
```

--------------------------------

### ModuleRecord()._get_comment_docstring

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/module_record

Retrieves the comment docstring preceding an object from the source code, returning only lines starting with '#'.

```APIDOC
## ModuleRecord()._get_comment_docstring

### Description
Get comment docstring preceding the object from the source code. Returns only lines starting with `#`, lines joined with a single space.

### Arguments
* `node_record` - Node record for source lookup.

### Returns
A docstring as a string.

### Signature
```python
def _get_comment_docstring(self, node_record: NodeRecord) -> str:
    ...
```

### See also
* NodeRecord
```

--------------------------------

### BaseGenerator.generate_index Method Signature

Source: https://vemel.github.io/handsdown/handsdown/generators/base

Generates the main index file (README.md) for the project, which includes a tree structure of all modules.

```python
def generate_index(self) -> None:
    ... 

```

--------------------------------

### Initialize Table of Contents

Source: https://vemel.github.io/handsdown/handsdown/utils/markdown

Create a TableOfContents object by providing an iterable of Header objects.

```python
class TableOfContents:
    def __init__(self, headers: Iterable[Header]) -> None:
        ...
```

--------------------------------

### PathFinder

Source: https://vemel.github.io/handsdown/handsdown/utils/path_finder

Initializes the PathFinder with a root directory and optional glob expression. It helps in matching paths within the root using .gitignore-like include and exclude patterns.

```APIDOC
## PathFinder

### Description
Glob helper for matching paths inside `root` path. Supports `.gitignore`-like `include` and `exclude` patterns.

### Arguments
* `root` - Path to root folder.
* `glob_expr` - `glob` expression to lookup in `root`

### Raises
* `PathFinderError` - If `root` is not absolute or not a directory.

### Signature
```python
class PathFinder:
    def __init__(self, root: Path) -> None:
        ...
```
```

--------------------------------

### Get Related Names of a Function

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/function_record

Returns a set of names related to the function. This is a property that can be accessed directly.

```python
@property
def related_names(self) -> Set[str]:
    ..."""
```

--------------------------------

### ClassRecord Initialization

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/class_record

Initializes a ClassRecord with an AST class definition node.

```python
class ClassRecord(NodeRecord):
    def __init__(self, node: ast.ClassDef) -> None:
        ...
```

--------------------------------

### Create ModuleRecord from Source

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/module_record

Class method to create a new ModuleRecord instance from a Python source file path. Requires the source path, import string, and optionally encoding.

```python
@classmethod
def create_from_source(
    cls, source_path: Path, import_string: ImportString, encoding: str = ENCODING
) -> "ModuleRecord":
    ... 

```

--------------------------------

### BaseDocstringProcessor.build_sections Method Signature

Source: https://vemel.github.io/handsdown/handsdown/processors/base

Parses the docstring content and splits it into sections. Returns a dictionary mapping section names to lists of strings.

```python
def build_sections(self, content: str) -> SectionMap:
    ...

```

--------------------------------

### Getting the length of import string parts with length

Source: https://vemel.github.io/handsdown/handsdown/utils/import_string

Returns the number of parts in the import string after splitting by dots.

```python
@property
def length(self) -> int:
    ... 
```

--------------------------------

### Getting all parent import strings with get_parents

Source: https://vemel.github.io/handsdown/handsdown/utils/import_string

Returns a list of all parent ImportString instances for the current import string.

```python
def get_parents(self: _R) -> List[_R]:
    ... 
```

--------------------------------

### NodeRecord().related_names

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/node_record

Gets a set of referenced object names within the node. This method should be overridden by child classes.

```APIDOC
## NodeRecord().related_names

### Description
Get a set of referenced object names in `node`. Returns an empty set, should be overriden by a child class.

### Returns
A set of referenced object name.

### Signature
```python
@property
def related_names(self) -> Set[str]:
    ... 
```
```

--------------------------------

### ModuleRecordList().add

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/module_record_list

Adds a new ModuleRecord to the list.

```APIDOC
## ModuleRecordList().add

### Description
Add new `ModuleRecord`.

### Arguments
* `module_record` - A new `ModuleRecord`

### Signature
```python
def add(self, module_record: ModuleRecord) -> None:
    ...
```

### See also
* ModuleRecord
```

--------------------------------

### ImportString Class

Source: https://vemel.github.io/handsdown/handsdown/utils/import_string

Wrapper for Python import strings. Initializes with an import string value.

```APIDOC
## ImportString

### Description
Wrapper for python import strings.

### Arguments
* `value` - Import string.

### Signature
```python
class ImportString:
    def __init__(self, value: str) -> None:
        ...
```
```

--------------------------------

### BaseGenerator.generate_doc Method Signature

Source: https://vemel.github.io/handsdown/handsdown/generators/base

Generates documentation for a single module file. Raises GeneratorError if the source path is not found within the current repository.

```python
def generate_doc(self, source_path: Path) -> None:
    ... 

```

--------------------------------

### Get MDDocument Table of Contents Section

Source: https://vemel.github.io/handsdown/handsdown/md_document

Access the toc_section property to retrieve the document's table of contents as a string.

```python
@property
def toc_section(self) -> str:
    ...
```

--------------------------------

### RSTExample.reference Method Signature

Source: https://vemel.github.io/handsdown/examples/sphinx_docstrings

Shows the static method signature for reference.

```python
@staticmethod
def reference():
    ...

```

--------------------------------

### Get Jinja2 Environment

Source: https://vemel.github.io/handsdown/handsdown/jinja_manager

Access the jinja2.Environment object managed by JinjaManager. This property allows retrieval of the current Jinja2 environment instance.

```python
@property
def env(self) -> jinja2.Environment:
    ...
```

--------------------------------

### parse_args

Source: https://vemel.github.io/handsdown/handsdown/cli_parser

Parses command-line arguments and returns a CLINamespace object.

```APIDOC
## parse_args

### Description
Get CLI arguments parser.

### Returns
An `argparse.ArgumentParser` instance.

### Signature
```python
def parse_args(args: Iterable[str]) -> CLINamespace:
    ...
```

### See also
  * CLINamespace
```

--------------------------------

### Get Comment Docstring Signature

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/module_record

Signature for the _get_comment_docstring method, used to retrieve comment docstrings preceding an object in the source code.

```python
def _get_comment_docstring(self, node_record: NodeRecord) -> str:
    ... 

```

--------------------------------

### PathFinder mkdir Method Signature

Source: https://vemel.github.io/handsdown/handsdown/utils/path_finder

Signature for the 'mkdir' method, used to create parent directories if they do not exist.

```python
def mkdir(self, force: bool = False) -> None:
    ...
```

--------------------------------

### SmartDocstringProcessor().build_sections

Source: https://vemel.github.io/handsdown/handsdown/processors/smart

Parses the provided docstring content and divides it into distinct sections. Each section is returned as an array of strings.

```APIDOC
## SmartDocstringProcessor().build_sections

### Description
Parse docstring and split it to sections with arrays of strings.

### Arguments
  * `content` - Object docstring.

### Returns
A dictionary where key is a section name and value is a list of string sof this section.

### Signature
```
def build_sections(self, content: str) -> SectionMap:
    ...

```

### See also
  * SectionMap
```

--------------------------------

### Analyze Module Function Definitions

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/module_analyzer

Parses information about module `def ...` statements. Adds nodes to `function_nodes`, skipping those with names starting with '_'.

```python
def my_func(arg1):
    return arg1
```

--------------------------------

### ModuleRecord.create_from_source

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/module_record

Class method to create a new ModuleRecord instance directly from a Python source file path.

```APIDOC
## ModuleRecord.create_from_source

### Description
Create new ModuleRecord from path.

### Arguments
* `source_path` - Path to a Python source file.
* `import_string` - File absolute import string.
* `encoding` - File encoding.

### Returns
New ModuleRecord instance.

### Signature
```python
@classmethod
def create_from_source(
    cls, source_path: Path, import_string: ImportString, encoding: str = ENCODING
) -> "ModuleRecord":
    ...
```

### See also
* ENCODING
* ImportString
```

--------------------------------

### get_external_configs_templates Method Signature

Source: https://vemel.github.io/handsdown/handsdown/generators/material

Retrieves external configuration templates. This method returns a tuple of template path to project path pairs.

```python
def get_external_configs_templates(self) -> Tuple[Tuple[Path, Path], ...]:
    ...

```

--------------------------------

### Analyze Module Class Definitions

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/module_analyzer

Parses information about module `class ...` statements. Adds nodes to `class_nodes`, skipping those with names starting with '_'.

```python
class MyClass():
    pass
```

--------------------------------

### Get Stdout Stream Logger

Source: https://vemel.github.io/handsdown/handsdown/utils/logger

Retrieves a logging.Logger instance configured for stdout stream output. Accepts an optional logging level argument.

```python
def get_logger(level: Optional[int] = None) -> logging.Logger:
    ...
```

--------------------------------

### TextRecord Initialization

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/text_record

Initializes a TextRecord with an AST node and its corresponding text representation. This is used for text-only expression nodes.

```python
class TextRecord(ExpressionRecord):
    def __init__(self, node: ast.AST, text: str) -> None:
        ...
```

--------------------------------

### Get Function Definition Lines Signature

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/module_record

Signature for the _get_function_def_lines method, which retrieves all function definition lines for comment type hints lookup.

```python
def _get_function_def_lines(self, function_record: FunctionRecord) -> List[str]:
    ... 

```

--------------------------------

### BaseGenerator.get_see_also_links Method Signature

Source: https://vemel.github.io/handsdown/handsdown/generators/base

Generates a list of links to other modules referenced in the docstring of a given node record.

```python
def get_see_also_links(
    self, record: NodeRecord, module_record: ModuleRecord, md_document: MDDocument
) -> List[str]:
    ... 

```

--------------------------------

### Function with Tuple and Type Hint for Class

Source: https://vemel.github.io/handsdown/examples/comment_typed

Shows a function `func` that accepts a tuple of string lists and a type hint for a `MyValue` class. It also includes keyword-only arguments with a `None` type hint.

```python
def func(
    _list: Tuple[List[str], ...], _my_value_cls: Type[MyValue] = MyValue, **_kwargs: None
) -> Any:
    ...
```

--------------------------------

### Hello Function Signature

Source: https://vemel.github.io/handsdown/examples/main_example

Defines the signature for the 'hello' function, including type annotations for the 'name' argument and the return value. It takes a string and returns a string.

```python
def hello(name: str) -> str:
    ...
```

--------------------------------

### MDDocument Class Initialization

Source: https://vemel.github.io/handsdown/handsdown/md_document

Initializes an MDDocument object, which can be used as a context manager to write content to a specified file path upon exiting the context.

```APIDOC
## MDDocument()

### Description
Initializes an MDDocument object. Can be used as a context manager, on exit context is written to `path`.

### Arguments
* `path` - Path to store document.
* `encoding` - File encoding. Defaults to ENCODING.

### Signature
```python
class MDDocument:
    def __init__(self, path: Path, encoding: str = ENCODING) -> None:
        ...
```
```

--------------------------------

### DocstringFormatter._cleanup Static Method Signature

Source: https://vemel.github.io/handsdown/handsdown/utils/docstring_formatter

A static method to fix multiline docstrings that may not start with a newline after the opening quotes. It returns an aligned docstring.

```python
@staticmethod
def _cleanup(docstring: str) -> str:
    ...
```

--------------------------------

### Function with Simple Arguments

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/function_analyzer

Demonstrates a function definition with various types of simple arguments, including positional, default-valued, variable positional (*args), and variable keyword (**kwargs).

```python
# simple arguments
def my_func(
    arg1,
    arg_default="value",
    *args,
    **kwargs,
):
    pass
```

--------------------------------

### ImportRecord.match Method Usage

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/import_record

Demonstrates how to use the match method to check if an imported name or its children match a given string. This method is useful for verifying if a specific name is accessible through the import.

```python
import_node = ast.parse('from my_module import Name as LocalName')
import_record = ImportRecord(import_node)

import_record.match('LocalName')
True

import_record.match('LocalName.child')
True

import_record.match('OtherName')
False

import_record.match('LocalNameOther')
False
```

--------------------------------

### Get Module Record

Source: https://vemel.github.io/handsdown/handsdown/loader

Constructs a ModuleRecord for a given source file path. Returns None if the file is not meant to be imported, or raises LoaderError if loading fails.

```python
def get_module_record(self, source_path: Path) -> Optional[ModuleRecord]:
    ... 
```

--------------------------------

### BaseGenerator().generate_docs

Source: https://vemel.github.io/handsdown/handsdown/generators/base

Generates documentation for all modules within the project. This method orchestrates the documentation generation process for the entire project.

```APIDOC
## generate_docs

### Description
Generate all doc files at once.

### Signature
```python
def generate_docs(self) -> None:
    ...
```
```

--------------------------------

### Get Related Import Strings

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/module_record

Retrieves a set of related import strings found within the module's records. Useful for understanding module dependencies.

```python
def get_related_import_strings(self, node_record: NodeRecord) -> Set[ImportString]:
    ... 

```

--------------------------------

### Example of Sphinx Directives Test

Source: https://vemel.github.io/handsdown/examples/sphinx_docstrings

A Python function to test Sphinx directives, specifically checking if the sum of two distinct elements in an array equals a given number.

```python
def sum_eq_n?(arr, n)
    return true if arr.empty? && n == 0
    arr.product(arr).reject { |a,b| a == b }.any? { |a,b| a + b == n }
end

```

--------------------------------

### ImportString().bool

Source: https://vemel.github.io/handsdown/handsdown/utils/import_string

Checks if the import string is not empty. Returns True if not empty, False otherwise.

```APIDOC
## ImportString().bool

### Description
Check if not empty.

### Returns
True if not empty.

### Signature
```python
def __bool__(self) -> bool:
    ...
```

### Examples
```python
bool(ImportString("my_module"))
True

bool(ImportString(""))
False
```
```

--------------------------------

### PathFinder Initialization Signature

Source: https://vemel.github.io/handsdown/handsdown/utils/path_finder

The signature for initializing the PathFinder class, requiring a root Path object.

```python
class PathFinder:
    def __init__(self, root: Path) -> None:
        ...
```

--------------------------------

### Analyze Module Attribute Assignments with AnnAssign

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/module_analyzer

Parses information about module attribute statements using ast.AnnAssign. Adds new entries to `attribute_nodes`, skipping assignments with names starting with '_'.

```python
MY_MODULE_INT: int
MY_MODULE_ATTR: str = 'value'
```

--------------------------------

### BaseGenerator().generate_doc

Source: https://vemel.github.io/handsdown/handsdown/generators/base

Generates documentation for a single module file. It processes the specified source file and creates its corresponding documentation.

```APIDOC
## generate_doc

### Description
Generate one module doc at once.

### Arguments
* `source_path` (Path) - Path to source file.

### Raises
* `GeneratorError` - If `source_path` not found in current repo.

### Signature
```python
def generate_doc(self, source_path: Path) -> None:
    ...
```
```

--------------------------------

### extract_md_title

Source: https://vemel.github.io/handsdown/handsdown/utils/strings

Extracts the title from the first line of markdown content. If a title (starting with '#') is found, it returns the title and the rest of the content. Otherwise, it returns an empty string for the title and the original content.

```APIDOC
## Function: extract_md_title

### Description
Extracts the title from the first line of markdown content. If a title (starting with '#') is found, it returns the title and the rest of the content. Otherwise, it returns an empty string for the title and the original content.

### Signature
```python
def extract_md_title(content: str) -> Tuple[str, str]:
    ...
```

### Parameters
#### Arguments
* `content` (str) - The markdown content to process.

### Returns
A tuple containing the extracted title (str) and the remaining content (str).

### Examples
```python
extract_md_title('# Title\ncontent')
('Title', 'content')

extract_md_title('no title\ncontent')
('', 'no title\ncontent')
```
```

--------------------------------

### ClassRecord init_method Property

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/class_record

Provides access to the class's __init__ method as an optional FunctionRecord.

```python
@property
def init_method(self) -> Optional[FunctionRecord]:
    ...
```

--------------------------------

### Render Markdown Link to Local Document

Source: https://vemel.github.io/handsdown/handsdown/md_document

Shows how to render Markdown links to local MD documents, handling relative paths and anchors. Useful for cross-referencing within documentation.

```python
md_doc = MDDocument(path='/root/parent/doc.md')
MDDocument.render_doc_link(
    'my title',
    anchor='my-anchor',
    target_path=Path('/root/parent/doc.md'
)
'[my title](#my-anchor)'
```

```python
MDDocument.render_doc_link('my title', target_path=Path('/root/parent/other.md'))
'[my title](other.md)'
```

```python
MDDocument.render_doc_link('my title', anchor='my-anchor', target_path=Path('doc.md'))
'[my title](doc.md#my-anchor)'
```

```python
MDDocument.render_doc_link('my title', anchor='my-anchor')
'[my title](#my-anchor)'
```

--------------------------------

### Render Jinja2 Template

Source: https://vemel.github.io/handsdown/handsdown/jinja_manager

Renders a Jinja2 template from a given file path with provided keyword arguments. This method takes a template path and any additional context variables for rendering.

```python
def render(self, template_path: Path, **kwargs: Any) -> str:
    ...
```

--------------------------------

### Analyze Module Attribute Assignments with Assign

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/analyzers/module_analyzer

Parses information about module attribute statements using ast.Assign. Adds new entries to `attribute_nodes`, skipping assignments to non-variables, multiple assignments, and names starting with '_'. Parses '__all__' to add values to `all_names`.

```python
MY_MODULE_ATTR = 'value'
    my_attr = "value"
__all__ = ['MyClass', 'my_func']

# these entries are skipped
_MY_MODULE_ATTR = "value"
multi_attr_1, multi_attr_2 = [1, 2]
my_object.name = "value"
__all__ = all_list
```

--------------------------------

### ModuleRecordList

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/module_record_list

Initializes an aggregation of ModuleRecord objects.

```APIDOC
## ModuleRecordList

### Description
Initializes an aggregation of `ModuleRecord` objects.

### Signature
```python
class ModuleRecordList:
    def __init__(self) -> None:
        ...
```
```

--------------------------------

### Loader()._get_output_path

Source: https://vemel.github.io/handsdown/handsdown/loader

Retrieves the output Markdown document path for a given source file path.

```APIDOC
## Loader()._get_output_path

### Description
Get output MD document path based on `source_path`.

### Arguments
* `source_path` (Path) - Path to source code file.

### Returns
A path to the output `.md` file even if it does not exist yet.

### Signature
```python
def _get_output_path(self, source_path: Path) -> Path:
    ...
```
```

--------------------------------

### Typed Classmethod with Type Hints

Source: https://vemel.github.io/handsdown/examples/comment_typed

Demonstrates a classmethod within the `Typed` class, showing type hints for the class itself (`cls`), a `MyValue` instance, variable string arguments, and keyword arguments.

```python
@classmethod
def classmethod(cls, _my_value: MyValue, *_args: str, **_kwargs: Any) -> Typed:
    ...
```

--------------------------------

### BaseGenerator().generate_index

Source: https://vemel.github.io/handsdown/handsdown/generators/base

Generates the main index file (e.g., README.md) for the project. This file typically contains a tree structure of all modules in the project, providing an overview and navigation.

```APIDOC
## generate_index

### Description
Generate `<output>/README.md` file. Contains a Tree of all modules in the project.

### Signature
```python
def generate_index(self) -> None:
    ...
```
```

--------------------------------

### BaseDocstringProcessor().build_sections

Source: https://vemel.github.io/handsdown/handsdown/processors/base

Parses a docstring and splits it into sections, returning a dictionary of section names to their content.

```APIDOC
## BaseDocstringProcessor().build_sections

### Description
Parse docstring and split it to sections with arrays of strings.

### Arguments
- `content` (str) - Object docstring.

### Returns
A dictionary where key is a section name and value is a list of strings of this section.

### Signature
```python
def build_sections(self, content: str) -> SectionMap:
    ...
```

### See also
- SectionMap
```

--------------------------------

### ModuleRecord().is_init

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/node_records/module_record

Checks if the current module is the `__init__.py` file.

```APIDOC
## ModuleRecord().is_init

### Description
Check if this module is the **init**.py file.

### Returns
True if this module is the **init**.py file.

### Signature
```python
def is_init(self) -> bool:
    ...
```
```

--------------------------------

### ModuleRecordList().get_package_names

Source: https://vemel.github.io/handsdown/handsdown/ast_parser/module_record_list

Retrieves a set of top-level package import strings.

```APIDOC
## ModuleRecordList().get_package_names

### Description
Get top level import strings.

### Returns
A set of top level imports as strings.

### Signature
```python
def get_package_names(self) -> Set[str]:
    ...
```
```
Tokens:
Raw