deadcode 2.2.2__py3-none-any.whl → 2.3.0__py3-none-any.whl

black/action/main.py

@@ -0,0 +1,176 @@
+import os
+import re
+import shlex
+import shutil
+import sys
+from pathlib import Path
+from subprocess import PIPE, STDOUT, run
+from typing import Union
+
+ACTION_PATH = Path(os.environ["GITHUB_ACTION_PATH"])
+ENV_PATH = ACTION_PATH / ".black-env"
+ENV_BIN = ENV_PATH / ("Scripts" if sys.platform == "win32" else "bin")
+OPTIONS = os.getenv("INPUT_OPTIONS", default="")
+SRC = os.getenv("INPUT_SRC", default="")
+JUPYTER = os.getenv("INPUT_JUPYTER") == "true"
+BLACK_ARGS = os.getenv("INPUT_BLACK_ARGS", default="")
+VERSION = os.getenv("INPUT_VERSION", default="")
+USE_PYPROJECT = os.getenv("INPUT_USE_PYPROJECT") == "true"
+
+BLACK_VERSION_RE = re.compile(r"^black([^A-Z0-9._-]+.*)$", re.IGNORECASE)
+EXTRAS_RE = re.compile(r"\[.*\]")
+
+
+def determine_version_specifier() -> str:
+    """Determine the version of Black to install.
+
+    The version can be specified either via the `with.version` input or via the
+    pyproject.toml file if `with.use_pyproject` is set to `true`.
+    """
+    if USE_PYPROJECT and VERSION:
+        print(
+            "::error::'with.version' and 'with.use_pyproject' inputs are "
+            "mutually exclusive.",
+            file=sys.stderr,
+            flush=True,
+        )
+        sys.exit(1)
+    if USE_PYPROJECT:
+        return read_version_specifier_from_pyproject()
+    elif VERSION and VERSION[0] in "0123456789":
+        return f"=={VERSION}"
+    else:
+        return VERSION
+
+
+def read_version_specifier_from_pyproject() -> str:
+    if sys.version_info < (3, 11):
+        print(
+            "::error::'with.use_pyproject' input requires Python 3.11 or later.",
+            file=sys.stderr,
+            flush=True,
+        )
+        sys.exit(1)
+
+    import tomllib  # type: ignore[import-not-found,unreachable]
+
+    try:
+        with Path("pyproject.toml").open("rb") as fp:
+            pyproject = tomllib.load(fp)
+    except FileNotFoundError:
+        print(
+            "::error::'with.use_pyproject' input requires a pyproject.toml file.",
+            file=sys.stderr,
+            flush=True,
+        )
+        sys.exit(1)
+
+    version = pyproject.get("tool", {}).get("black", {}).get("required-version")
+    if version is not None:
+        return f"=={version}"
+
+    arrays = [
+        pyproject.get("project", {}).get("dependencies"),
+        *pyproject.get("project", {}).get("optional-dependencies", {}).values(),
+    ]
+    for array in arrays:
+        version = find_black_version_in_array(array)
+        if version is not None:
+            break
+
+    if version is None:
+        print(
+            "::error::'black' dependency missing from pyproject.toml.",
+            file=sys.stderr,
+            flush=True,
+        )
+        sys.exit(1)
+
+    return version
+
+
+def find_black_version_in_array(array: object) -> Union[str, None]:
+    if not isinstance(array, list):
+        return None
+    try:
+        for item in array:
+            # Rudimentary PEP 508 parsing.
+            item = item.split(";")[0]
+            item = EXTRAS_RE.sub("", item).strip()
+            if item == "black":
+                print(
+                    "::error::Version specifier missing for 'black' dependency in "
+                    "pyproject.toml.",
+                    file=sys.stderr,
+                    flush=True,
+                )
+                sys.exit(1)
+            elif m := BLACK_VERSION_RE.match(item):
+                return m.group(1).strip()
+    except TypeError:
+        pass
+
+    return None
+
+
+run([sys.executable, "-m", "venv", str(ENV_PATH)], check=True)
+
+version_specifier = determine_version_specifier()
+if JUPYTER:
+    extra_deps = "[colorama,jupyter]"
+else:
+    extra_deps = "[colorama]"
+if version_specifier:
+    req = f"black{extra_deps}{version_specifier}"
+else:
+    describe_name = ""
+    with open(ACTION_PATH / ".git_archival.txt", encoding="utf-8") as fp:
+        for line in fp:
+            if line.startswith("describe-name: "):
+                describe_name = line[len("describe-name: ") :].rstrip()
+                break
+    if not describe_name:
+        print("::error::Failed to detect action version.", file=sys.stderr, flush=True)
+        sys.exit(1)
+    # expected format is one of:
+    # - 23.1.0
+    # - 23.1.0-51-g448bba7
+    if describe_name.count("-") < 2:
+        # the action's commit matches a tag exactly, install exact version from PyPI
+        req = f"black{extra_deps}=={describe_name}"
+    else:
+        # the action's commit does not match any tag, install from the local git repo
+        req = f".{extra_deps}"
+print(f"Installing {req}...", flush=True)
+pip_proc = run(
+    [str(ENV_BIN / "python"), "-m", "pip", "install", req],
+    stdout=PIPE,
+    stderr=STDOUT,
+    encoding="utf-8",
+    cwd=ACTION_PATH,
+)
+if pip_proc.returncode:
+    print(pip_proc.stdout)
+    print("::error::Failed to install Black.", file=sys.stderr, flush=True)
+    sys.exit(pip_proc.returncode)
+
+
+base_cmd = [str(ENV_BIN / "black")]
+if BLACK_ARGS:
+    # TODO: remove after a while since this is deprecated in favour of SRC + OPTIONS.
+    proc = run(
+        [*base_cmd, *shlex.split(BLACK_ARGS)],
+        stdout=PIPE,
+        stderr=STDOUT,
+        encoding="utf-8",
+    )
+else:
+    proc = run(
+        [*base_cmd, *shlex.split(OPTIONS), *shlex.split(SRC)],
+        stdout=PIPE,
+        stderr=STDOUT,
+        encoding="utf-8",
+    )
+shutil.rmtree(ENV_PATH, ignore_errors=True)
+print(proc.stdout)
+sys.exit(proc.returncode)

black/docs/conf.py

@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+#
+# Configuration file for the Sphinx documentation builder.
+#
+# This file does only contain a selection of the most common options. For a
+# full list see the documentation:
+# http://www.sphinx-doc.org/en/stable/config
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+
+import os
+import string
+from importlib.metadata import version
+from pathlib import Path
+
+CURRENT_DIR = Path(__file__).parent
+
+
+def make_pypi_svg(version: str) -> None:
+    template: Path = CURRENT_DIR / "_static" / "pypi_template.svg"
+    target: Path = CURRENT_DIR / "_static" / "pypi.svg"
+    with open(str(template), "r", encoding="utf8") as f:
+        svg: str = string.Template(f.read()).substitute(version=version)
+    with open(str(target), "w", encoding="utf8") as f:
+        f.write(svg)
+
+
+# Necessary so Click doesn't hit an encode error when called by
+# sphinxcontrib-programoutput on Windows.
+os.putenv("pythonioencoding", "utf-8")
+
+# -- Project information -----------------------------------------------------
+
+project = "Black"
+copyright = "2018-Present, Łukasz Langa and contributors to Black"
+author = "Łukasz Langa and contributors to Black"
+
+# Autopopulate version
+# The version, including alpha/beta/rc tags, but not commit hash and datestamps
+release = version("black").split("+")[0]
+# The short X.Y version.
+version = release
+for sp in "abcfr":
+    version = version.split(sp)[0]
+
+make_pypi_svg(release)
+
+
+# -- General configuration ---------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+needs_sphinx = "4.4"
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.napoleon",
+    "myst_parser",
+    "sphinxcontrib.programoutput",
+    "sphinx_copybutton",
+]
+
+# If you need extensions of a certain version or higher, list them here.
+needs_extensions = {"myst_parser": "0.13.7"}
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+source_suffix = [".rst", ".md"]
+
+# The master toctree document.
+master_doc = "index"
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = "en"
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path .
+
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = "sphinx"
+
+# We need headers to be linkable to so ask MyST-Parser to autogenerate anchor IDs for
+# headers up to and including level 3.
+myst_heading_anchors = 3
+
+# Prettier support formatting some MyST syntax but not all, so let's disable the
+# unsupported yet still enabled by default ones.
+myst_disable_syntax = [
+    "colon_fence",
+    "myst_block_break",
+    "myst_line_comment",
+    "math_block",
+]
+
+# Optional MyST Syntaxes
+myst_enable_extensions = []
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = "furo"
+html_logo = "_static/logo2-readme.png"
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ["_static"]
+
+# Custom sidebar templates, must be a dictionary that maps document names
+# to template names.
+#
+# The default sidebars (for documents that don't match any pattern) are
+# defined by theme itself.  Builtin themes are using these templates by
+# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
+# 'searchbox.html']``.
+#
+# html_sidebars = {}
+
+
+# -- Options for HTMLHelp output ---------------------------------------------
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = "blackdoc"
+
+
+# -- Options for LaTeX output ------------------------------------------------
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [(
+    master_doc,
+    "black.tex",
+    "Documentation for Black",
+    "Łukasz Langa and contributors to Black",
+    "manual",
+)]
+
+
+# -- Options for manual page output ------------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [(master_doc, "black", "Documentation for Black", [author], 1)]
+
+
+# -- Options for Texinfo output ----------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [(
+    master_doc,
+    "Black",
+    "Documentation for Black",
+    author,
+    "Black",
+    "The uncompromising Python code formatter",
+    "Miscellaneous",
+)]
+
+
+# -- Options for Epub output -------------------------------------------------
+
+# Bibliographic Dublin Core info.
+epub_title = project
+epub_author = author
+epub_publisher = author
+epub_copyright = copyright
+
+# The unique identifier of the text. This can be a ISBN number
+# or the project homepage.
+#
+# epub_identifier = ''
+
+# A unique identification for the text.
+#
+# epub_uid = ''
+
+# A list of files that should not be packed into the epub file.
+epub_exclude_files = ["search.html"]
+
+
+# -- Extension configuration -------------------------------------------------
+
+autodoc_member_order = "bysource"
+
+#  -- sphinx-copybutton configuration ----------------------------------------
+copybutton_prompt_text = (
+    r">>> |\.\.\. |> |\$ |\# | In \[\d*\]: | {2,5}\.\.\.: | {5,8}: "
+)
+copybutton_prompt_is_regexp = True
+copybutton_remove_prompts = True
+
+# -- Options for intersphinx extension ---------------------------------------
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {"<name>": ("https://docs.python.org/3/", None)}

black/gallery/gallery.py

@@ -0,0 +1,294 @@
+import atexit
+import json
+import subprocess
+import tarfile
+import tempfile
+import traceback
+import venv
+import zipfile
+from argparse import ArgumentParser, Namespace
+from concurrent.futures import ThreadPoolExecutor
+from functools import lru_cache, partial
+from pathlib import Path
+from typing import Generator, List, NamedTuple, Optional, Tuple, Union, cast
+from urllib.request import urlopen, urlretrieve
+
+PYPI_INSTANCE = "https://pypi.org/pypi"
+PYPI_TOP_PACKAGES = (
+    "https://hugovk.github.io/top-pypi-packages/top-pypi-packages-30-days.min.json"
+)
+INTERNAL_BLACK_REPO = f"{tempfile.gettempdir()}/__black"
+
+ArchiveKind = Union[tarfile.TarFile, zipfile.ZipFile]
+
+subprocess.run = partial(subprocess.run, check=True)  # type: ignore
+# https://github.com/python/mypy/issues/1484
+
+
+class BlackVersion(NamedTuple):
+    version: str
+    config: Optional[str] = None
+
+
+def get_pypi_download_url(package: str, version: Optional[str]) -> str:
+    with urlopen(PYPI_INSTANCE + f"/{package}/json") as page:
+        metadata = json.load(page)
+
+    if version is None:
+        sources = metadata["urls"]
+    else:
+        if version in metadata["releases"]:
+            sources = metadata["releases"][version]
+        else:
+            raise ValueError(
+                f"No releases found with version ('{version}') tag. "
+                f"Found releases: {metadata['releases'].keys()}"
+            )
+
+    for source in sources:
+        if source["python_version"] == "source":
+            break
+    else:
+        raise ValueError(f"Couldn't find any sources for {package}")
+
+    return cast(str, source["url"])
+
+
+def get_top_packages() -> List[str]:
+    with urlopen(PYPI_TOP_PACKAGES) as page:
+        result = json.load(page)
+
+    return [package["project"] for package in result["rows"]]
+
+
+def get_package_source(package: str, version: Optional[str]) -> str:
+    if package == "cpython":
+        if version is None:
+            version = "main"
+        return f"https://github.com/python/cpython/archive/{version}.zip"
+    elif package == "pypy":
+        if version is None:
+            version = "branch/default"
+        return (
+            f"https://foss.heptapod.net/pypy/pypy/repository/{version}/archive.tar.bz2"
+        )
+    else:
+        return get_pypi_download_url(package, version)
+
+
+def get_archive_manager(local_file: str) -> ArchiveKind:
+    if tarfile.is_tarfile(local_file):
+        return tarfile.open(local_file)
+    elif zipfile.is_zipfile(local_file):
+        return zipfile.ZipFile(local_file)
+    else:
+        raise ValueError("Unknown archive kind.")
+
+
+def get_first_archive_member(archive: ArchiveKind) -> str:
+    if isinstance(archive, tarfile.TarFile):
+        return archive.getnames()[0]
+    elif isinstance(archive, zipfile.ZipFile):
+        return archive.namelist()[0]
+
+
+def download_and_extract(package: str, version: Optional[str], directory: Path) -> Path:
+    source = get_package_source(package, version)
+
+    local_file, _ = urlretrieve(source, directory / f"{package}-src")
+    with get_archive_manager(local_file) as archive:
+        archive.extractall(path=directory)
+        result_dir = get_first_archive_member(archive)
+    return directory / result_dir
+
+
+def get_package(
+    package: str, version: Optional[str], directory: Path
+) -> Optional[Path]:
+    try:
+        return download_and_extract(package, version, directory)
+    except Exception:
+        print(f"Caught an exception while downloading {package}.")
+        traceback.print_exc()
+        return None
+
+
+DEFAULT_SLICE = slice(None)  # for flake8
+
+
+def download_and_extract_top_packages(
+    directory: Path,
+    workers: int = 8,
+    limit: slice = DEFAULT_SLICE,
+) -> Generator[Path, None, None]:
+    with ThreadPoolExecutor(max_workers=workers) as executor:
+        bound_downloader = partial(get_package, version=None, directory=directory)
+        for package in executor.map(bound_downloader, get_top_packages()[limit]):
+            if package is not None:
+                yield package
+
+
+def git_create_repository(repo: Path) -> None:
+    subprocess.run(["git", "init"], cwd=repo)
+    git_add_and_commit(msg="Initial commit", repo=repo)
+
+
+def git_add_and_commit(msg: str, repo: Path) -> None:
+    subprocess.run(["git", "add", "."], cwd=repo)
+    subprocess.run(["git", "commit", "-m", msg, "--allow-empty"], cwd=repo)
+
+
+def git_switch_branch(
+    branch: str, repo: Path, new: bool = False, from_branch: Optional[str] = None
+) -> None:
+    args = ["git", "checkout"]
+    if new:
+        args.append("-b")
+    args.append(branch)
+    if from_branch:
+        args.append(from_branch)
+    subprocess.run(args, cwd=repo)
+
+
+def init_repos(options: Namespace) -> Tuple[Path, ...]:
+    options.output.mkdir(exist_ok=True)
+
+    if options.top_packages:
+        source_directories = tuple(
+            download_and_extract_top_packages(
+                directory=options.output,
+                workers=options.workers,
+                limit=slice(None, options.top_packages),
+            )
+        )
+    else:
+        source_directories = (
+            download_and_extract(
+                package=options.pypi_package,
+                version=options.version,
+                directory=options.output,
+            ),
+        )
+
+    for source_directory in source_directories:
+        git_create_repository(source_directory)
+
+    if options.black_repo is None:
+        subprocess.run(
+            ["git", "clone", "https://github.com/psf/black.git", INTERNAL_BLACK_REPO],
+            cwd=options.output,
+        )
+        options.black_repo = options.output / INTERNAL_BLACK_REPO
+
+    return source_directories
+
+
+@lru_cache(8)
+def black_runner(version: str, black_repo: Path) -> Path:
+    directory = tempfile.TemporaryDirectory()
+    venv.create(directory.name, with_pip=True)
+
+    python = Path(directory.name) / "bin" / "python"
+    subprocess.run([python, "-m", "pip", "install", "-e", black_repo])
+
+    atexit.register(directory.cleanup)
+    return python
+
+
+def format_repo_with_version(
+    repo: Path,
+    from_branch: Optional[str],
+    black_repo: Path,
+    black_version: BlackVersion,
+    input_directory: Path,
+) -> str:
+    current_branch = f"black-{black_version.version}"
+    git_switch_branch(black_version.version, repo=black_repo)
+    git_switch_branch(current_branch, repo=repo, new=True, from_branch=from_branch)
+
+    format_cmd: List[Union[Path, str]] = [
+        black_runner(black_version.version, black_repo),
+        (black_repo / "black.py").resolve(),
+        ".",
+    ]
+    if black_version.config:
+        format_cmd.extend(["--config", input_directory / black_version.config])
+
+    subprocess.run(format_cmd, cwd=repo, check=False)  # ensure the process
+    # continuess to run even it can't format some files. Reporting those
+    # should be enough
+    git_add_and_commit(f"Format with black:{black_version.version}", repo=repo)
+
+    return current_branch
+
+
+def format_repos(repos: Tuple[Path, ...], options: Namespace) -> None:
+    black_versions = tuple(
+        BlackVersion(*version.split(":")) for version in options.versions
+    )
+
+    for repo in repos:
+        from_branch = None
+        for black_version in black_versions:
+            from_branch = format_repo_with_version(
+                repo=repo,
+                from_branch=from_branch,
+                black_repo=options.black_repo,
+                black_version=black_version,
+                input_directory=options.input,
+            )
+        git_switch_branch("main", repo=repo)
+
+    git_switch_branch("main", repo=options.black_repo)
+
+
+def main() -> None:
+    parser = ArgumentParser(description="""Black Gallery is a script that
+    automates the process of applying different Black versions to a selected
+    PyPI package and seeing the results between versions.""")
+
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("-p", "--pypi-package", help="PyPI package to download.")
+    group.add_argument(
+        "-t", "--top-packages", help="Top n PyPI packages to download.", type=int
+    )
+
+    parser.add_argument("-b", "--black-repo", help="Black's Git repository.", type=Path)
+    parser.add_argument(
+        "-v",
+        "--version",
+        help=(
+            "Version for given PyPI package. Will be discarded if used with -t option."
+        ),
+    )
+    parser.add_argument(
+        "-w",
+        "--workers",
+        help=(
+            "Maximum number of threads to download with at the same time. "
+            "Will be discarded if used with -p option."
+        ),
+    )
+    parser.add_argument(
+        "-i",
+        "--input",
+        default=Path("/input"),
+        type=Path,
+        help="Input directory to read configuration.",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        default=Path("/output"),
+        type=Path,
+        help="Output directory to download and put result artifacts.",
+    )
+    parser.add_argument("versions", nargs="*", default=("main",), help="")
+
+    options = parser.parse_args()
+    repos = init_repos(options)
+    format_repos(repos, options)
+
+
+if __name__ == "__main__":
+    main()