uv-metadata 1.0.0__py3-none-any.whl

uv_metadata-1.0.0.dist-info/METADATA

@@ -0,0 +1,205 @@
+Metadata-Version: 2.4
+Name: uv-metadata
+Version: 1.0.0
+Summary: Inspect any Python package metadata without installing
+Author: Zoran Simic
+Project-URL: Homepage, https://github.com/zsimic/uv-metadata
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: build
+Requires-Dist: pyproject-hooks
+Requires-Dist: seekablehttpfile
+Dynamic: license-file
+
+# uv-metadata
+
+Inspect any Python package metadata from any source without installing.
+
+```shell
+$ uvx uv-metadata requests -kversion
+2.32.4
+
+$ uvx uv-metadata requests -krequires_python
+>=3.10
+
+$ uvx uv-metadata 'pip<23' -kversion
+22.3.1
+```
+
+Works with published packages, local wheels/sdists, project folders, and git repos.
+For published packages, metadata is streamed directly from the remote wheel via HTTP range
+requests — typically a few KB, no full download needed.
+
+
+## Why this is useful
+
+Getting package metadata as JSON from a simple CLI opens up a lot of possibilities:
+
+- **Scripting**: what's the latest version of a package? What about the last 2.x release?
+  What's the latest version that still supports Python 3.7?
+  (`uvx uv-metadata -p3.7 setuptools -kversion`)
+- **Validation**: CI checks that verify your package metadata is complete before publishing —
+  are author, URL, license, classifiers all present?
+- **Verifying your own project**: after setting up dynamic versioning (e.g. `setuptools-scm`),
+  just run `uvx uv-metadata .` to confirm your metadata looks right — no need to build or install
+- **Dependency auditing**: quickly check what a package requires, what Python versions it supports,
+  or what entry points it exposes — all without installing anything
+
+This project also serves as a reference implementation for a proposed native
+[`uv metadata`](https://github.com/zsimic/uv-metadata/blob/main/uv-metadata-spec.md) subcommand
+(see [astral-sh/uv#6037](https://github.com/astral-sh/uv/issues/6037) and the [spec](https://github.com/zsimic/uv-metadata/blob/main/uv-metadata-spec.md)).
+
+Requires `uv` on `PATH`.
+
+
+## Installation
+
+```shell
+# Run directly (no install needed)
+uvx uv-metadata requests
+
+# Or install permanently
+uv tool install uv-metadata
+```
+
+
+## Quick examples
+
+```shell
+# Full metadata as JSON
+uvx uv-metadata flask
+
+# Single key
+uvx uv-metadata flask -kversion
+
+# Version constraint
+uvx uv-metadata 'flask<3' -kversion
+
+# Local project
+uvx uv-metadata .
+
+# Local wheel or sdist
+uvx uv-metadata ./dist/mypackage-1.0.0-py3-none-any.whl
+
+# Git repo
+uvx uv-metadata git+https://github.com/psf/requests@main
+
+# Target a specific Python version
+uvx uv-metadata numpy -p3.9 -kversion
+```
+
+
+## Input routing
+
+| Input | Strategy |
+|---|---|
+| `.`, `./path`, `/abs/path`, or any existing filesystem path | |
+| &emsp;directory with `pyproject.toml` or `setup.py` | Build metadata via PEP 517 |
+| &emsp;`*.dist-info` or `*.egg-info` directory | Read directly |
+| &emsp;`*.whl` or `*.zip` file | Extract from zip archive |
+| &emsp;`*.tar.gz` file | Extract from tarball |
+| `git+https://...`, `git@...`, or `pkg @ url` | Install to temp dir, read dist-info |
+| plain name or version constraint (`name`, `name>=x`, etc.) | Resolve via uv, stream dist-info from remote wheel; fall back to downloading sdist |
+
+
+## Output format
+
+JSON with sorted keys. The `description` (long description) field is omitted by default
+as it is typically very large; use `--full` to include it.
+
+```shell
+$ uvx uv-metadata pip
+{
+    "author_email": "The pip developers <distutils-sig@python.org>",
+    "classifiers": [
+        "Development Status :: 5 - Production/Stable",
+        ...
+    ],
+    "description_content_type": "text/x-rst",
+    "entry_points": {
+        "console_scripts": {
+            "pip": "pip._internal.cli.main:main",
+            "pip3": "pip._internal.cli.main:main"
+        }
+    },
+    "license_expression": "MIT",
+    "metadata_version": "2.4",
+    "name": "pip",
+    "project_url": [
+        "Documentation, https://pip.pypa.io",
+        "Source, https://github.com/pypa/pip"
+    ],
+    "requires_python": ">=3.9",
+    "summary": "The PyPA recommended tool for installing Python packages.",
+    "version": "26.0.1"
+}
+```
+
+Structural rules:
+- Keys are `lower_snake_case`
+- Single-occurrence fields: plain string
+- Multi-occurrence fields: list of strings
+- `entry_points`: `{"group": {"name": "module:attr"}}`
+- `top_level`: list of top-level importable names
+- `UNKNOWN` values are omitted
+
+
+## CLI reference
+
+```
+usage: uv-metadata [-h] [-p PYTHON] [-k KEY] [--full] [package]
+
+Output the metadata of a package, in machine-readable format
+
+positional arguments:
+  package              Package to inspect (default: current folder)
+
+options:
+  -h, --help           show this help message and exit
+  -p, --python PYTHON  Python version to target (e.g. 3.11)
+  -k, --key KEY        Show only this key from the metadata
+  --full               Include full description in output
+```
+
+
+## How it works
+
+### Fast path for published packages
+
+1. `uv pip compile --format pylock.toml` resolves to a concrete wheel URL without downloading
+2. `SeekableHttpFile` + `ZipFile` streams only the dist-info files via HTTP range requests
+3. Falls back to downloading the sdist when no wheel is available
+
+### Unified metadata reading
+
+All extraction strategies produce a dist-info folder which is read by
+`importlib.metadata.PathDistribution`. Both `METADATA` (wheels) and `PKG-INFO` (sdists)
+are handled transparently.
+
+### Archive extraction
+
+A `MetadataReader` base class with `ZipReader` and `TarReader` implementations provides
+uniform member discovery and extraction across archive formats.
+
+
+## Dependencies
+
+| Package | Purpose |
+|---|---|
+| [`build`](https://pypi.org/project/build/) | PEP 517 metadata building for local project folders |
+| [`pyproject-hooks`](https://pypi.org/project/pyproject-hooks/) | Quiet subprocess runner used by `build` |
+| [`seekablehttpfile`](https://pypi.org/project/seekablehttpfile/) | HTTP range requests for streaming dist-info from remote wheels |
+
+
+## Relevant PEPs
+
+- [PEP 241](https://peps.python.org/pep-0241/) – Metadata for Python Software Packages 1.0
+- [PEP 314](https://peps.python.org/pep-0314/) – Metadata for Python Software Packages 1.1
+- [PEP 345](https://peps.python.org/pep-0345/) – Metadata for Python Software Packages 1.2
+- [PEP 566](https://peps.python.org/pep-0566/) – Metadata for Python Software Packages 2.1
+- [PEP 508](https://peps.python.org/pep-0508/) – Dependency specification for Python Software Packages
+- [PEP 517](https://peps.python.org/pep-0517/) – A build-system independent format for source trees
+- [PEP 643](https://peps.python.org/pep-0643/) – Metadata for Package Source Distributions
+- [PEP 658](https://peps.python.org/pep-0658/) – Serve Distribution Metadata in the Simple Repository API
+- [PEP 639](https://peps.python.org/pep-0639/) – Improving License Clarity with Better Package Metadata

uv_metadata-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+uv_metadata.py,sha256=3IJjUC2hTFWDc-b-gfkEgVtgASm352TVCkbqACGAsTw,14275
+uv_metadata-1.0.0.dist-info/licenses/LICENSE,sha256=Wg8W1zKdVdkZG_QoZHrymsB4tVDfDp0sins7rX6I8Wc,1068
+uv_metadata-1.0.0.dist-info/METADATA,sha256=trUS0spywi815IyIuX4CzO5q3WpEotPwOJIsq_py1Zw,6929
+uv_metadata-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+uv_metadata-1.0.0.dist-info/entry_points.txt,sha256=l2EWpbBjzrirgT76hfTBb9yWw8doTcEPiBjj-kD7pxc,49
+uv_metadata-1.0.0.dist-info/top_level.txt,sha256=jn_269ii1E0GGNYjKi4pYn8-9w5srCfsPkVlhiLalCQ,12
+uv_metadata-1.0.0.dist-info/RECORD,,

uv_metadata-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

uv_metadata-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+uv-metadata = uv_metadata:main

uv_metadata-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Zoran Simic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

uv_metadata-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+uv_metadata

uv_metadata.py

@@ -0,0 +1,409 @@
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+from abc import ABC, abstractmethod
+from importlib.metadata import PathDistribution
+from pathlib import Path
+from typing import NoReturn
+from zipfile import ZipFile
+
+import pyproject_hooks
+from build import ProjectBuilder
+from build.env import IsolatedEnv
+from seekablehttpfile import SeekableHttpFile
+
+METADATA_FILES = ("METADATA", "PKG-INFO", "entry_points.txt", "top_level.txt")
+_INFO_DIR_RX = re.compile(r"^(.+\.(dist|egg)-info)/(" + "|".join(re.escape(f) for f in METADATA_FILES) + r")$")
+_ROOT_PKG_INFO_RX = re.compile(r"^([^/]+)/PKG-INFO$")
+UV_PATH = shutil.which("uv")
+
+
+def abort(msg: str = "") -> NoReturn:
+    sys.exit(msg)
+
+
+def abort_if(condition, msg: str = ""):
+    if condition:
+        sys.exit(msg)
+
+
+def canonical_git_url(url: str) -> str:
+    if url.startswith("git@"):
+        # Autocorrect default git SSH URLs (allows copy-pasting from github.com)
+        url = "git+ssh://" + url.replace(":", "/", 1)
+
+    elif url.startswith("https://") and not url.endswith(".git"):
+        url = f"git+{url}"
+
+    return url
+
+
+def run_uv(*args, fatal=True, env=None, input=None):
+    assert UV_PATH is not None
+    full_cmd = [UV_PATH, *args]
+    result = subprocess.run(full_cmd, input=input, capture_output=True, check=False, env=env, text=True)
+    if result.returncode:
+        args = " ".join(x for x in args)
+        abort_if(fatal, f"'uv {args}' failed with exit code {result.returncode}:\n{result.stderr}")
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Routing
+# ---------------------------------------------------------------------------
+
+
+def get_metadata_from_pip_spec(pip_spec: str, python: str | None = None) -> dict:
+    """
+    Get metadata for a package, routing to the best extraction strategy:
+
+    - local folder (contains pyproject.toml or setup.py) → build metadata via ProjectBuilder
+    - local *.dist-info or *.egg-info folder → read directly
+    - local .whl or .tar.gz file → extract from archive
+    - git URL or direct reference → install to temp dir, read dist-info
+    - plain package name (optionally version-constrained) → resolve via uv without installing,
+      then stream only the metadata from the remote wheel (much faster than a full install)
+
+    Examples::
+
+        get_metadata_from_pip_spec(".")
+        get_metadata_from_pip_spec("requests")
+        get_metadata_from_pip_spec("requests>=2.28")
+        get_metadata_from_pip_spec("./dist/mypackage-1.0.0.whl")
+        get_metadata_from_pip_spec("git+https://github.com/user/repo@main")
+    """
+    if not pip_spec:
+        pip_spec = str(Path(".").absolute())
+
+    # Path-like: starts with common path prefixes or is an existing file/dir
+    if pip_spec.startswith(("~", ".", "/")) or os.path.exists(pip_spec):
+        path = Path(pip_spec).expanduser().resolve()
+        if not path.is_dir():
+            abort_if(not path.name.lower().endswith((".whl", ".zip", ".tar.gz")), f"Unknown package type '{path.name}'")
+            return extract_metadata_from_file(path)
+
+        if path.name.lower().endswith("-info"):
+            return extract_metadata_from_dist_info(path)
+
+        return extract_metadata_from_project_folder(path, python)
+
+    if "://" in pip_spec or pip_spec.startswith("git@") or (" @ " in pip_spec):
+        # Git SSH shorthand: git@github.com:user/repo  or direct reference: pkg @ url
+        return extract_metadata_from_uv_install(canonical_git_url(pip_spec), python)
+
+    # Plain package name (optionally version-constrained): use fast resolve path
+    return extract_metadata_from_uv_resolve(pip_spec, python)
+
+
+# ---------------------------------------------------------------------------
+# Extraction functions
+# ---------------------------------------------------------------------------
+
+
+def extract_metadata_from_dist_info(folder: Path) -> dict:
+    """Convert a .(egg|dist)-info directory to a clean metadata dict via importlib.metadata"""
+    dist = PathDistribution(folder)
+    if not dist.metadata:
+        abort(f"No metadata files in {folder.name}")
+
+    result: dict = {}
+    for key, value in dist.metadata.json.items():
+        if isinstance(value, list):
+            value = [v for v in value if v != "UNKNOWN"]
+
+        elif value == "UNKNOWN":
+            value = None
+
+        if value:
+            result[key] = value
+
+    eps = dist.entry_points
+    if eps:
+        grouped: dict = {}
+        for ep in eps:
+            grouped.setdefault(ep.group, {})[ep.name] = ep.value
+
+        result["entry_points"] = grouped
+
+    top_level = dist.read_text("top_level.txt")
+    if top_level:
+        result["top_level"] = top_level.strip().splitlines()
+
+    return result
+
+
+def extract_metadata_from_project_folder(project_folder: Path, python: str | None = None) -> dict:
+    """Build package metadata from a source tree using PEP 517 (via the 'build' library)"""
+    abort_if(not project_folder.is_dir(), "folder does not exist")
+    abort_if(
+        not (project_folder / "pyproject.toml").exists() and not (project_folder / "setup.py").exists(),
+        "no pyproject.toml or setup.py",
+    )
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir_path = Path(tmpdir)
+        venv_folder = tmpdir_path / ".venv"
+        env = dict(os.environ)
+        env["UV_VENV_SEED"] = "0"
+        env["VIRTUAL_ENV"] = str(venv_folder)
+        venv_args = ["venv"]
+        if python:
+            venv_args.append(f"-p{python}")
+
+        run_uv(*venv_args, str(venv_folder), env=env)
+        isolated_env = _UvIsolatedEnv(venv_folder)
+        builder = ProjectBuilder.from_isolated_env(isolated_env, project_folder, runner=pyproject_hooks.quiet_subprocess_runner)
+        isolated_env.install(builder.build_system_requires)
+        isolated_env.install(builder.get_requires_for_build("wheel"))
+        meta_path = builder.metadata_path(tmpdir_path)
+        return extract_metadata_from_dist_info(Path(meta_path))
+
+
+def extract_metadata_from_file(path: Path) -> dict:
+    """Extract metadata from a local .whl or .tar.gz file"""
+    abort_if(not path.is_file(), f"File '{path}' does not exist")
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir_path = Path(tmpdir)
+        reader_type = ZipReader if path.name.lower().endswith((".whl", ".zip")) else TarReader
+        with reader_type(path) as reader:
+            return reader.extracted_metadata_members(tmpdir_path)
+
+
+def extract_metadata_from_uv_install(pip_spec: str, python: str | None = None) -> dict:
+    """Install package to a temp dir and read the resulting dist-info (used for git/URL specs)"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        target = Path(tmpdir) / "target"
+        args = ["-q", "pip", "install", "--no-deps", "--target", str(target)]
+        if python:
+            args.append(f"-p{python}")
+        args.append(pip_spec)
+        run_uv(*args)
+        info = list(target.glob("*.dist-info"))
+        abort_if(len(info) != 1, f"expected 1 dist-info folder, got: {[p.name for p in info]}")
+        return extract_metadata_from_dist_info(info[0])
+
+
+def extract_metadata_from_uv_resolve(pip_spec: str, python: str | None = None) -> dict:
+    """
+    Resolve package metadata without installing — much faster than a full install.
+
+    Uses 'uv pip compile --format pylock.toml' to find the wheel URL, then streams
+    only the metadata section from the remote .whl via HTTP range requests.
+    Falls back to downloading the sdist when no wheel is available.
+    """
+    args = [
+        "-q",
+        "pip",
+        "compile",
+        "--no-deps",
+        "--no-header",
+        "--universal",
+        "--no-sources",
+        "--format",
+        "pylock.toml",
+        "--fork-strategy",
+        "fewest",
+        "--resolution",
+        "highest",
+        # Use python-version '99' to get latest metadata regardless of local python.
+        # When the caller specifies a python version, honor it so metadata reflects that target.
+        "--python-version",
+        python or "99",
+    ]
+    r = run_uv(*args, "-", input=pip_spec, fatal=False)
+    if not r.returncode and r.stdout:
+        m = re.search(r'\burl\s*=\s*"([^"]+\.whl)"', r.stdout)
+        if m:
+            wheel_url = m.group(1)
+            with tempfile.TemporaryDirectory() as tmpdir:
+                streamed = SeekableHttpFile(wheel_url, check_etag=False)
+                with ZipReader(streamed) as reader:
+                    return reader.extracted_metadata_members(Path(tmpdir))
+
+        # Fallback: download sdist and extract metadata from it
+        m = re.search(r'\burl\s*=\s*"([^"]+)"', r.stdout)
+        if m:
+            return _download_and_extract(m.group(1))
+
+    msg = (r.stderr or "uv resolve failed with an empty stderr").strip()
+    if "not found in the package registry" in " ".join(x.strip() for x in msg.splitlines()):
+        msg = f"Package '{pip_spec}' does not exist"
+
+    abort(msg)
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _download_and_extract(url: str) -> dict:
+    """Download an archive from a URL and extract metadata from it"""
+    from urllib.request import urlopen
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        dest = Path(tmpdir) / url.rsplit("/", 1)[-1]
+        with urlopen(url) as resp:
+            dest.write_bytes(resp.read())
+
+        return extract_metadata_from_file(dest)
+
+
+class MetadataReader(ABC):
+    """Context manager that abstracts extraction of metadata from zip/tar files"""
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_args):
+        self.close()
+
+    @abstractmethod
+    def close(self) -> None:
+        """Release underlying archive resources"""
+
+    def find_metadata_members(self) -> list:
+        """Find archive members containing package metadata.
+
+        Prefers .dist-info/.egg-info directories, falls back to root-level PKG-INFO.
+        """
+        members = self.getmembers()
+        matched = [m for m in members if _INFO_DIR_RX.match(self.filepath(m))]
+        if not matched:
+            matched = [m for m in members if _ROOT_PKG_INFO_RX.match(self.filepath(m))]
+
+        abort_if(not matched, f"No metadata found in {self}")
+        return matched
+
+    def extracted_metadata_members(self, tmpdir: Path) -> dict:
+        members = self.find_metadata_members()
+        info_dir = tmpdir / "tmp.dist-info"
+        info_dir.mkdir()
+        for m in members:
+            b = self.read_bytes(m)
+            name = os.path.basename(self.filepath(m))
+            if name == "PKG-INFO":
+                name = "METADATA"
+
+            (info_dir / name).write_bytes(b)
+
+        return extract_metadata_from_dist_info(info_dir)
+
+    @abstractmethod
+    def filepath(self, member) -> str:
+        """Path of `member` within the archive"""
+
+    @abstractmethod
+    def getmembers(self) -> list:
+        """Return a list of contained file members"""
+
+    @abstractmethod
+    def read_bytes(self, member) -> bytes:
+        """Read bytes from `member`"""
+
+
+class ZipReader(MetadataReader):
+    def __init__(self, source: Path | SeekableHttpFile):
+        self.source = source
+        self.zip_file = ZipFile(source)  # type: ignore[arg-type]
+
+    def __repr__(self):
+        return str(self.source)
+
+    def close(self) -> None:
+        self.zip_file.close()
+
+    def filepath(self, member) -> str:
+        return member.filename
+
+    def getmembers(self) -> list:
+        return self.zip_file.filelist
+
+    def read_bytes(self, member) -> bytes:
+        return self.zip_file.read(member.filename)
+
+
+class TarReader(MetadataReader):
+    def __init__(self, path: Path):
+        self.path = path
+        self.tar_file = tarfile.open(path)
+
+    def __repr__(self):
+        return str(self.path)
+
+    def close(self) -> None:
+        self.tar_file.close()
+
+    def filepath(self, member) -> str:
+        return member.name
+
+    def getmembers(self) -> list:
+        return self.tar_file.getmembers()
+
+    def read_bytes(self, member) -> bytes:
+        f = self.tar_file.extractfile(member)
+        return f.read() if f else b""
+
+
+class _UvIsolatedEnv(IsolatedEnv):
+    def __init__(self, venv_folder: Path):
+        self.venv_folder = venv_folder
+
+    @property
+    def python_executable(self) -> str:
+        return str(self.venv_folder / "bin/python")
+
+    def make_extra_environ(self) -> dict:
+        return {}
+
+    def install(self, requirements) -> None:
+        if requirements:
+            run_uv("pip", "install", "--python", self.python_executable, *requirements)
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+def main(args=None):
+    """
+    Output the metadata of a package, in machine-readable format
+
+    Examples:
+        uv-metadata requests
+        uv-metadata "requests>=2.28"
+        uv-metadata .
+        uv-metadata ./dist/mypackage-1.0.0.whl
+        uv-metadata ./dist/mypackage-1.0.0.tar.gz
+        uv-metadata git+https://github.com/zsimic/uv-metadata@main
+    """
+    parser = argparse.ArgumentParser(description=main.__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("-p", "--python", help="Python version to target (e.g. 3.11)")
+    parser.add_argument("-k", "--key", help="Show only this key from the metadata")
+    parser.add_argument("--full", action="store_true", help="Include full description in output")
+    parser.add_argument("package", default=None, nargs="?", help="Package to inspect (default: current folder)")
+    args = parser.parse_args(args=args)
+
+    meta_dict = get_metadata_from_pip_spec(args.package, args.python)
+    if not args.full:
+        meta_dict.pop("description", None)
+
+    if args.key is None:
+        print(json.dumps(meta_dict, indent=4, sort_keys=True))
+
+    else:
+        value = meta_dict.get(args.key)
+        abort_if(value is None, f"no key '{args.key}' in metadata")
+        print(value if isinstance(value, str) else json.dumps(value, indent=4, sort_keys=True))
+
+
+if __name__ == "__main__":
+    sys.exit(main())