How to use the requirementslib.models.setup_info.ast_parse_setup_py function in requirementslib

def test_ast_parser_finds_fully_qualified_setup(setup_py_dir):
    target = setup_py_dir.joinpath(
        "package_using_fully_qualified_setuptools/setup.py"
    ).as_posix()
    parsed = ast_parse_setup_py(target)
    analyzer = ast_parse_file(target)
    expected = {
        "name": "test_package",
        "version": "1.0.0",
        "description": "The Backend HTTP Server",
        "long_description": "This is a package",
        "install_requires": ["six"],
        "tests_require": ["coverage", "flaky"],
        "extras_require": {"testing": ["coverage", "flaky"]},
        "package_dir": {"": "src"},
        "packages": ["test_package"],
        "include_package_data": True,
        "zip_safe": False,
    }
    for k, v in expected.items():
        assert k in parsed

def test_ast_parser_handles_repeated_assignments(setup_py_dir):
    target = setup_py_dir.joinpath(
        "package_with_repeated_assignments/setup.py"
    ).as_posix()
    parsed = ast_parse_setup_py(target)
    analyzer = ast_parse_file(target)
    assert parsed["name"] == "test_package_with_repeated_assignments"
    assert isinstance(parsed["version"], str) is False
    assert parsed["install_requires"] == ["six"]
    analyzer_parsed = analyzer.parse_setup_function()
    # the versions in this instance are AST objects as they come from
    # os.environ and will need to be parsed downstream from here, so
    # equality comparisons will fail
    analyzer_parsed.pop("version")
    parsed.pop("version")
    assert analyzer_parsed == parsed

def test_ast_parser_handles_exceptions(artifact_dir):
    path = artifact_dir.joinpath("git/pyinstaller/setup.py")
    result = ast_parse_setup_py(path.as_posix())
    analyzer = ast_parse_file(path.as_posix())
    assert result is not None
    assert "altgraph" in result["install_requires"]
    for k, v in analyzer.parse_setup_function().items():
        assert k in result
        assert result[k] == v or (
            isinstance(v, dict) and isinstance(list(v.keys())[0], ast.Attribute)
        )

def test_ast_parser_handles_annoted_assignments(setup_py_dir):
    parsed = ast_parse_setup_py(
        setup_py_dir.joinpath(
            "package_with_annoted_assignments/setup.py"
        ).as_posix()
    )
    assert parsed["extras_require"] == {"docs": ["sphinx", "sphinx-argparse"]}

def test_ast_parser_handles_dependency_on_env_vars(
    env_vars, expected_install_requires, setup_py_dir
):
    @contextlib.contextmanager
    def modified_environ(**update):
        env = os.environ
        try:
            env.update(update)
            yield
        finally:
            [env.pop(k) for k in update]

    with modified_environ(**env_vars):
        parsed = ast_parse_setup_py(
            setup_py_dir.joinpath(
                "package_with_dependence_on_env_vars/setup.py"
            ).as_posix()
        )
        assert list(sorted(parsed["install_requires"])) == list(
            sorted(expected_install_requires)
        )

def test_ast_parser_finds_variables(setup_py_dir):
    target = setup_py_dir.joinpath("package_with_extras_as_variable/setup.py").as_posix()
    parsed = ast_parse_setup_py(target)
    analyzer = ast_parse_file(target)
    expected = {
        "name": "test_package",
        "version": "1.0.0",
        "description": "The Backend HTTP Server",
        "long_description": "This is a package",
        "install_requires": ["six"],
        "tests_require": ["coverage", "flaky"],
        "extras_require": {"testing": ["coverage", "flaky"]},
        "package_dir": {"": "src"},
        "packages": ["test_package"],
        "include_package_data": True,
        "zip_safe": False,
    }
    for k, v in expected.items():
        assert k in parsed

def test_ast_parser_handles_binops(setup_py_dir):
    target = setup_py_dir.joinpath("package_with_setup_from_dict/setup.py").as_posix()
    parsed = ast_parse_setup_py(target)
    analyzer = ast_parse_file(target)
    assert parsed["name"] == "test package"
    assert parsed["version"] == "1.0.0"
    expected = [
        "pytest",
        "flake8",
    ]
    assert list(sorted(parsed["extras_require"]["tests"])) == list(sorted(expected))
    assert analyzer.parse_setup_function() == parsed