From b9c017034b5ccd217c31ebc2b44669a92f553f16 Mon Sep 17 00:00:00 2001
From: chrysle <96722107+chrysle@users.noreply.github.com>
Date: Fri, 3 May 2024 21:03:08 +0200
Subject: [PATCH 1/4] Add support for JSON output format

---
 piptools/scripts/compile.py |  3 ++
 piptools/scripts/options.py |  4 ++
 piptools/utils.py           |  3 +-
 piptools/writer.py          | 89 ++++++++++++++++++++++++++++++-------
 tests/test_writer.py        | 19 ++++----
 5 files changed, 91 insertions(+), 27 deletions(-)

diff --git a/piptools/scripts/compile.py b/piptools/scripts/compile.py
index 2b4522eb..bcbb65ce 100755
--- a/piptools/scripts/compile.py
+++ b/piptools/scripts/compile.py
@@ -82,6 +82,7 @@ def _determine_linesep(
 @options.color
 @options.verbose
 @options.quiet
+@options.json
 @options.dry_run
 @options.pre
 @options.rebuild
@@ -127,6 +128,7 @@ def cli(
     color: bool | None,
     verbose: int,
     quiet: int,
+    json: bool,
     dry_run: bool,
     pre: bool,
     rebuild: bool,
@@ -514,6 +516,7 @@ def cli(
         cast(BinaryIO, output_file),
         click_ctx=ctx,
         dry_run=dry_run,
+        json_output=json,
         emit_header=header,
         emit_index_url=emit_index_url,
         emit_trusted_host=emit_trusted_host,
diff --git a/piptools/scripts/options.py b/piptools/scripts/options.py
index 98fbbf7a..77f3a890 100644
--- a/piptools/scripts/options.py
+++ b/piptools/scripts/options.py
@@ -52,6 +52,10 @@ def _get_default_option(option_name: str) -> Any:
     help="Give less output",
 )
 
+json = click.option(
+    "-j", "--json", is_flag=True, default=False, help="Emit JSON output"
+)
+
 dry_run = click.option(
     "-n",
     "--dry-run",
diff --git a/piptools/utils.py b/piptools/utils.py
index 8d04f7a7..39a51e92 100644
--- a/piptools/utils.py
+++ b/piptools/utils.py
@@ -58,6 +58,7 @@
     "--cache-dir",
     "--no-reuse-hashes",
     "--no-config",
+    "--json",
 }
 
 # Set of option that are only negative, i.e. --no-<option>
@@ -352,7 +353,7 @@ def get_compile_command(click_ctx: click.Context) -> str:
         - removing values that are already default
         - sorting the arguments
         - removing one-off arguments like '--upgrade'
-        - removing arguments that don't change build behaviour like '--verbose'
+        - removing arguments that don't change build behaviour like '--verbose' or '--json'
     """
     from piptools.scripts.compile import cli
 
diff --git a/piptools/writer.py b/piptools/writer.py
index da603f1f..9497a781 100644
--- a/piptools/writer.py
+++ b/piptools/writer.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import io
+import json
 import os
 import re
 import sys
@@ -79,6 +80,7 @@ def __init__(
         dst_file: BinaryIO,
         click_ctx: Context,
         dry_run: bool,
+        json_output: bool,
         emit_header: bool,
         emit_index_url: bool,
         emit_trusted_host: bool,
@@ -99,6 +101,7 @@ def __init__(
         self.dst_file = dst_file
         self.click_ctx = click_ctx
         self.dry_run = dry_run
+        self.json_output = json_output
         self.emit_header = emit_header
         self.emit_index_url = emit_index_url
         self.emit_trusted_host = emit_trusted_host
@@ -191,14 +194,61 @@ def write_flags(self) -> Iterator[str]:
         if emitted:
             yield ""
 
-    def _iter_lines(
+    def _get_json(
+        self,
+        ireq: InstallRequirement,
+        line: str,
+        hashes: dict[InstallRequirement, set[str]] | None = None,
+        unsafe: bool = False,
+    ) -> dict[str, str]:
+        """Get a JSON representation for an ``InstallRequirement``."""
+        output_hashes = []
+        if hashes:
+            ireq_hashes = hashes.get(ireq)
+            if ireq_hashes:
+                assert isinstance(ireq_hashes, set)
+                output_hashes = list(ireq_hashes)
+        hashable = True
+        if ireq.link:
+            if ireq.link.is_vcs or (ireq.link.is_file and ireq.link.is_existing_dir()):
+                hashable = False
+        markers = ""
+        if ireq.markers:
+            markers = str(ireq.markers)
+        # Retrieve parent requirements from constructed line
+        splitted_line = [m.strip() for m in unstyle(line).split("#")]
+        try:
+            via = splitted_line[splitted_line.index("via") + 1 :]
+        except ValueError:
+            via = [splitted_line[-1][len("via ") :]]
+            if via[0].startswith("-r"):
+                req_files = re.split(r"\s|,", via[0])
+                del req_files[0]
+                via = ["-r"]
+                for req_file in req_files:
+                    via.append(os.path.abspath(req_file))
+        ireq_json = {
+            "name": ireq.name,
+            "version": str(ireq.specifier).lstrip("=="),
+            "requirement": str(ireq.req),
+            "via": via,
+            "line": unstyle(line),
+            "hashable": hashable,
+            "editable": ireq.editable,
+            "hashes": output_hashes,
+            "markers": markers,
+            "unsafe": unsafe,
+        }
+        return ireq_json
+
+    def _iter_ireqs(
         self,
         results: set[InstallRequirement],
         unsafe_requirements: set[InstallRequirement],
         unsafe_packages: set[str],
         markers: dict[str, Marker],
         hashes: dict[InstallRequirement, set[str]] | None = None,
-    ) -> Iterator[str]:
+    ) -> Iterator[str, dict[str, str]]:
         # default values
         unsafe_packages = unsafe_packages if self.allow_unsafe else set()
         hashes = hashes or {}
@@ -209,12 +259,11 @@ def _iter_lines(
         has_hashes = hashes and any(hash for hash in hashes.values())
 
         yielded = False
-
         for line in self.write_header():
-            yield line
+            yield line, {}
             yielded = True
         for line in self.write_flags():
-            yield line
+            yield line, {}
             yielded = True
 
         unsafe_requirements = unsafe_requirements or {
@@ -225,36 +274,36 @@ def _iter_lines(
         if packages:
             for ireq in sorted(packages, key=self._sort_key):
                 if has_hashes and not hashes.get(ireq):
-                    yield MESSAGE_UNHASHED_PACKAGE
+                    yield MESSAGE_UNHASHED_PACKAGE, {}
                     warn_uninstallable = True
                 line = self._format_requirement(
                     ireq, markers.get(key_from_ireq(ireq)), hashes=hashes
                 )
-                yield line
+                yield line, self._get_json(ireq, line, hashes=hashes)
             yielded = True
 
         if unsafe_requirements:
-            yield ""
+            yield "", {}
             yielded = True
             if has_hashes and not self.allow_unsafe:
-                yield MESSAGE_UNSAFE_PACKAGES_UNPINNED
+                yield MESSAGE_UNSAFE_PACKAGES_UNPINNED, {}
                 warn_uninstallable = True
             else:
-                yield MESSAGE_UNSAFE_PACKAGES
+                yield MESSAGE_UNSAFE_PACKAGES, {}
 
             for ireq in sorted(unsafe_requirements, key=self._sort_key):
                 ireq_key = key_from_ireq(ireq)
                 if not self.allow_unsafe:
-                    yield comment(f"# {ireq_key}")
+                    yield comment(f"# {ireq_key}"), {}
                 else:
                     line = self._format_requirement(
                         ireq, marker=markers.get(ireq_key), hashes=hashes
                     )
-                    yield line
+                    yield line, self._get_json(ireq, line, unsafe=True)
 
         # Yield even when there's no real content, so that blank files are written
         if not yielded:
-            yield ""
+            yield "", {}
 
         if warn_uninstallable:
             log.warning(MESSAGE_UNINSTALLABLE)
@@ -267,7 +316,8 @@ def write(
         markers: dict[str, Marker],
         hashes: dict[InstallRequirement, set[str]] | None,
     ) -> None:
-        if not self.dry_run:
+        output_structure = []
+        if not self.dry_run or self.json_output:
             dst_file = io.TextIOWrapper(
                 self.dst_file,
                 encoding="utf8",
@@ -275,19 +325,24 @@ def write(
                 line_buffering=True,
             )
         try:
-            for line in self._iter_lines(
+            for line, ireq in self._iter_ireqs(
                 results, unsafe_requirements, unsafe_packages, markers, hashes
             ):
                 if self.dry_run:
                     # Bypass the log level to always print this during a dry run
                     log.log(line)
                 else:
-                    log.info(line)
+                    if not self.json_output:
+                        log.info(line)
                     dst_file.write(unstyle(line))
                     dst_file.write("\n")
+                if self.json_output and ireq:
+                    output_structure.append(ireq)
         finally:
-            if not self.dry_run:
+            if not self.dry_run or self.json_output:
                 dst_file.detach()
+            if self.json_output:
+                print(json.dumps(output_structure, indent=4))
 
     def _format_requirement(
         self,
diff --git a/tests/test_writer.py b/tests/test_writer.py
index dd435448..b3e98785 100644
--- a/tests/test_writer.py
+++ b/tests/test_writer.py
@@ -34,6 +34,7 @@ def writer(tmpdir_cwd):
             dst_file=ctx.params["output_file"],
             click_ctx=ctx,
             dry_run=True,
+            json_output=False,
             emit_header=True,
             emit_index_url=True,
             emit_trusted_host=True,
@@ -108,11 +109,11 @@ def test_format_requirement_environment_marker(from_line, writer):
 
 
 @pytest.mark.parametrize("allow_unsafe", ((True,), (False,)))
-def test_iter_lines__unsafe_dependencies(writer, from_line, allow_unsafe):
+def test_iter_ireqs__unsafe_dependencies(writer, from_line, allow_unsafe):
     writer.allow_unsafe = allow_unsafe
     writer.emit_header = False
 
-    lines = writer._iter_lines(
+    lines = writer._iter_ireqs(
         {from_line("test==1.2")},
         {from_line("setuptools==1.10.0")},
         unsafe_packages=set(),
@@ -128,14 +129,14 @@ def test_iter_lines__unsafe_dependencies(writer, from_line, allow_unsafe):
     assert tuple(lines) == expected_lines
 
 
-def test_iter_lines__unsafe_with_hashes(capsys, writer, from_line):
+def test_iter_ireqs__unsafe_with_hashes(capsys, writer, from_line):
     writer.allow_unsafe = False
     writer.emit_header = False
     ireqs = [from_line("test==1.2")]
     unsafe_ireqs = [from_line("setuptools==1.10.0")]
     hashes = {ireqs[0]: {"FAKEHASH"}, unsafe_ireqs[0]: set()}
 
-    lines = writer._iter_lines(
+    lines = writer._iter_ireqs(
         ireqs, unsafe_ireqs, unsafe_packages=set(), markers={}, hashes=hashes
     )
 
@@ -151,13 +152,13 @@ def test_iter_lines__unsafe_with_hashes(capsys, writer, from_line):
     assert captured.err.strip() == MESSAGE_UNINSTALLABLE
 
 
-def test_iter_lines__hash_missing(capsys, writer, from_line):
+def test_iter_ireqs__hash_missing(capsys, writer, from_line):
     writer.allow_unsafe = False
     writer.emit_header = False
     ireqs = [from_line("test==1.2"), from_line("file:///example/#egg=example")]
     hashes = {ireqs[0]: {"FAKEHASH"}, ireqs[1]: set()}
 
-    lines = writer._iter_lines(
+    lines = writer._iter_ireqs(
         ireqs,
         hashes=hashes,
         unsafe_requirements=set(),
@@ -176,7 +177,7 @@ def test_iter_lines__hash_missing(capsys, writer, from_line):
     assert captured.err.strip() == MESSAGE_UNINSTALLABLE
 
 
-def test_iter_lines__no_warn_if_only_unhashable_packages(writer, from_line):
+def test_iter_ireqs__no_warn_if_only_unhashable_packages(writer, from_line):
     """
     There shouldn't be MESSAGE_UNHASHED_PACKAGE warning if there are only unhashable
     packages. See GH-1101.
@@ -189,7 +190,7 @@ def test_iter_lines__no_warn_if_only_unhashable_packages(writer, from_line):
     ]
     hashes = {ireq: set() for ireq in ireqs}
 
-    lines = writer._iter_lines(
+    lines = writer._iter_ireqs(
         ireqs,
         hashes=hashes,
         unsafe_requirements=set(),
@@ -453,7 +454,7 @@ def test_write_order(writer, from_line):
         "package-b==2.3.4",
         "package2==7.8.9",
     ]
-    result = writer._iter_lines(
+    result = writer._iter_ireqs(
         packages, unsafe_requirements=set(), unsafe_packages=set(), markers={}
     )
     assert list(result) == expected_lines

From d0548865d829fd6cf3a7835edc5e234be309312a Mon Sep 17 00:00:00 2001
From: chrysle <96722107+chrysle@users.noreply.github.com>
Date: Fri, 10 May 2024 15:30:00 +0200
Subject: [PATCH 2/4] Merge `_get_json` into `_format_requirement`

---
 piptools/writer.py | 98 +++++++++++++++++++---------------------------
 1 file changed, 41 insertions(+), 57 deletions(-)

diff --git a/piptools/writer.py b/piptools/writer.py
index 9497a781..a610cf88 100644
--- a/piptools/writer.py
+++ b/piptools/writer.py
@@ -194,53 +194,6 @@ def write_flags(self) -> Iterator[str]:
         if emitted:
             yield ""
 
-    def _get_json(
-        self,
-        ireq: InstallRequirement,
-        line: str,
-        hashes: dict[InstallRequirement, set[str]] | None = None,
-        unsafe: bool = False,
-    ) -> dict[str, str]:
-        """Get a JSON representation for an ``InstallRequirement``."""
-        output_hashes = []
-        if hashes:
-            ireq_hashes = hashes.get(ireq)
-            if ireq_hashes:
-                assert isinstance(ireq_hashes, set)
-                output_hashes = list(ireq_hashes)
-        hashable = True
-        if ireq.link:
-            if ireq.link.is_vcs or (ireq.link.is_file and ireq.link.is_existing_dir()):
-                hashable = False
-        markers = ""
-        if ireq.markers:
-            markers = str(ireq.markers)
-        # Retrieve parent requirements from constructed line
-        splitted_line = [m.strip() for m in unstyle(line).split("#")]
-        try:
-            via = splitted_line[splitted_line.index("via") + 1 :]
-        except ValueError:
-            via = [splitted_line[-1][len("via ") :]]
-            if via[0].startswith("-r"):
-                req_files = re.split(r"\s|,", via[0])
-                del req_files[0]
-                via = ["-r"]
-                for req_file in req_files:
-                    via.append(os.path.abspath(req_file))
-        ireq_json = {
-            "name": ireq.name,
-            "version": str(ireq.specifier).lstrip("=="),
-            "requirement": str(ireq.req),
-            "via": via,
-            "line": unstyle(line),
-            "hashable": hashable,
-            "editable": ireq.editable,
-            "hashes": output_hashes,
-            "markers": markers,
-            "unsafe": unsafe,
-        }
-        return ireq_json
-
     def _iter_ireqs(
         self,
         results: set[InstallRequirement],
@@ -276,10 +229,10 @@ def _iter_ireqs(
                 if has_hashes and not hashes.get(ireq):
                     yield MESSAGE_UNHASHED_PACKAGE, {}
                     warn_uninstallable = True
-                line = self._format_requirement(
+                line, json = self._format_requirement(
                     ireq, markers.get(key_from_ireq(ireq)), hashes=hashes
                 )
-                yield line, self._get_json(ireq, line, hashes=hashes)
+                yield line, json
             yielded = True
 
         if unsafe_requirements:
@@ -296,10 +249,10 @@ def _iter_ireqs(
                 if not self.allow_unsafe:
                     yield comment(f"# {ireq_key}"), {}
                 else:
-                    line = self._format_requirement(
+                    line, json = self._format_requirement(
                         ireq, marker=markers.get(ireq_key), hashes=hashes
                     )
-                    yield line, self._get_json(ireq, line, unsafe=True)
+                    yield line, json
 
         # Yield even when there's no real content, so that blank files are written
         if not yielded:
@@ -349,16 +302,14 @@ def _format_requirement(
         ireq: InstallRequirement,
         marker: Marker | None = None,
         hashes: dict[InstallRequirement, set[str]] | None = None,
-    ) -> str:
+        unsafe: bool = False,
+    ) -> tuple[str, dict[str, str | list[str]]]:
         ireq_hashes = (hashes if hashes is not None else {}).get(ireq)
 
         line = format_requirement(ireq, marker=marker, hashes=ireq_hashes)
         if self.strip_extras:
             line = strip_extras(line)
 
-        if not self.annotate:
-            return line
-
         # Annotate what packages or reqs-ins this package is required by
         required_by = set()
         if hasattr(ireq, "_source_ireqs"):
@@ -390,6 +341,39 @@ def _format_requirement(
                 annotation = strip_extras(annotation)
             # 24 is one reasonable column size to use here, that we've used in the past
             lines = f"{line:24}{sep}{comment(annotation)}".splitlines()
-            line = "\n".join(ln.rstrip() for ln in lines)
+            if self.annotate:
+                line = "\n".join(ln.rstrip() for ln in lines)
+
+        hashable = True
+        if ireq.link:
+            if ireq.link.is_vcs or (ireq.link.is_file and ireq.link.is_existing_dir()):
+                hashable = False
+        output_marker = ""
+        if marker:
+            output_marker = str(marker)
+        via = []
+        for parent_req in required_by:
+            if parent_req.startswith("-r "):
+                # Ensure paths to requirements files given are absolute
+                reqs_in_path = os.path.abspath(parent_req[len("-r ") :])
+                via.append(f"-r {reqs_in_path}")
+            else:
+                via.append(parent_req)
+        output_hashes = []
+        if ireq_hashes:
+            output_hashes = list(ireq_hashes)
+
+        ireq_json = {
+            "name": ireq.name,
+            "version": str(ireq.specifier).lstrip("=="),
+            "requirement": str(ireq.req),
+            "via": via,
+            "line": unstyle(line),
+            "hashable": hashable,
+            "editable": ireq.editable,
+            "hashes": output_hashes,
+            "marker": output_marker,
+            "unsafe": unsafe,
+        }
 
-        return line
+        return line, ireq_json

From 217f3581864a8cd1209b96c2bce888c5141fdf8d Mon Sep 17 00:00:00 2001
From: chrysle <96722107+chrysle@users.noreply.github.com>
Date: Sat, 11 May 2024 16:47:01 +0200
Subject: [PATCH 3/4] Write JSON output to `requirements.json`

---
 piptools/scripts/compile.py |  13 +++-
 piptools/writer.py          | 144 ++++++++++++++++++++----------------
 2 files changed, 89 insertions(+), 68 deletions(-)

diff --git a/piptools/scripts/compile.py b/piptools/scripts/compile.py
index bcbb65ce..ef5d5131 100755
--- a/piptools/scripts/compile.py
+++ b/piptools/scripts/compile.py
@@ -41,6 +41,7 @@
 )
 DEFAULT_REQUIREMENTS_FILE = "requirements.in"
 DEFAULT_REQUIREMENTS_OUTPUT_FILE = "requirements.txt"
+DEFAULT_REQUIREMENTS_OUTPUT_FILE_JSON = "requirements.json"
 METADATA_FILENAMES = frozenset({"setup.py", "setup.cfg", "pyproject.toml"})
 
 
@@ -220,10 +221,16 @@ def cli(
         # An output file must be provided for stdin
         if src_files == ("-",):
             raise click.BadParameter("--output-file is required if input is from stdin")
-        # Use default requirements output file if there is a setup.py the source file
+        # Use default requirements output file if the source file is a recognized
+        # packaging metadata file
         elif os.path.basename(src_files[0]) in METADATA_FILENAMES:
             file_name = os.path.join(
-                os.path.dirname(src_files[0]), DEFAULT_REQUIREMENTS_OUTPUT_FILE
+                os.path.dirname(src_files[0]),
+                (
+                    DEFAULT_REQUIREMENTS_OUTPUT_FILE_JSON
+                    if json
+                    else DEFAULT_REQUIREMENTS_OUTPUT_FILE
+                ),
             )
         # An output file must be provided if there are multiple source files
         elif len(src_files) > 1:
@@ -302,7 +309,7 @@ def cli(
     # Proxy with a LocalRequirementsRepository if --upgrade is not specified
     # (= default invocation)
     output_file_exists = os.path.exists(output_file.name)
-    if not upgrade and output_file_exists:
+    if not (upgrade or json) and output_file_exists:
         output_file_is_empty = os.path.getsize(output_file.name) == 0
         if upgrade_install_reqs and output_file_is_empty:
             log.warning(
diff --git a/piptools/writer.py b/piptools/writer.py
index a610cf88..224003df 100644
--- a/piptools/writer.py
+++ b/piptools/writer.py
@@ -201,7 +201,7 @@ def _iter_ireqs(
         unsafe_packages: set[str],
         markers: dict[str, Marker],
         hashes: dict[InstallRequirement, set[str]] | None = None,
-    ) -> Iterator[str, dict[str, str]]:
+    ) -> Iterator[str] | Iterator[dict[str, str | list[str]]]:
         # default values
         unsafe_packages = unsafe_packages if self.allow_unsafe else set()
         hashes = hashes or {}
@@ -212,12 +212,13 @@ def _iter_ireqs(
         has_hashes = hashes and any(hash for hash in hashes.values())
 
         yielded = False
-        for line in self.write_header():
-            yield line, {}
-            yielded = True
-        for line in self.write_flags():
-            yield line, {}
-            yielded = True
+        if not self.json_output:
+            for line in self.write_header():
+                yield line
+                yielded = True
+            for line in self.write_flags():
+                yield line
+                yielded = True
 
         unsafe_requirements = unsafe_requirements or {
             r for r in results if r.name in unsafe_packages
@@ -226,37 +227,39 @@ def _iter_ireqs(
 
         if packages:
             for ireq in sorted(packages, key=self._sort_key):
-                if has_hashes and not hashes.get(ireq):
-                    yield MESSAGE_UNHASHED_PACKAGE, {}
+                if has_hashes and not hashes.get(ireq) and not self.json_output:
+                    yield MESSAGE_UNHASHED_PACKAGE
                     warn_uninstallable = True
-                line, json = self._format_requirement(
+                formatted_req = self._format_requirement(
                     ireq, markers.get(key_from_ireq(ireq)), hashes=hashes
                 )
-                yield line, json
+                yield formatted_req
             yielded = True
 
         if unsafe_requirements:
-            yield "", {}
+
+            if not self.json_output:
+                yield ""
             yielded = True
-            if has_hashes and not self.allow_unsafe:
-                yield MESSAGE_UNSAFE_PACKAGES_UNPINNED, {}
+            if has_hashes and not self.allow_unsafe and not self.json_output:
+                yield MESSAGE_UNSAFE_PACKAGES_UNPINNED
                 warn_uninstallable = True
-            else:
-                yield MESSAGE_UNSAFE_PACKAGES, {}
+            elif not self.json_output:
+                yield MESSAGE_UNSAFE_PACKAGES
 
             for ireq in sorted(unsafe_requirements, key=self._sort_key):
                 ireq_key = key_from_ireq(ireq)
-                if not self.allow_unsafe:
-                    yield comment(f"# {ireq_key}"), {}
+                if not self.allow_unsafe and not self.json_output:
+                    yield comment(f"# {ireq_key}")
                 else:
-                    line, json = self._format_requirement(
+                    formatted_req = self._format_requirement(
                         ireq, marker=markers.get(ireq_key), hashes=hashes
                     )
-                    yield line, json
+                    yield formatted_req
 
         # Yield even when there's no real content, so that blank files are written
         if not yielded:
-            yield "", {}
+            yield ""
 
         if warn_uninstallable:
             log.warning(MESSAGE_UNINSTALLABLE)
@@ -270,7 +273,7 @@ def write(
         hashes: dict[InstallRequirement, set[str]] | None,
     ) -> None:
         output_structure = []
-        if not self.dry_run or self.json_output:
+        if not self.dry_run:
             dst_file = io.TextIOWrapper(
                 self.dst_file,
                 encoding="utf8",
@@ -278,24 +281,27 @@ def write(
                 line_buffering=True,
             )
         try:
-            for line, ireq in self._iter_ireqs(
+            for formatted_req in self._iter_ireqs(
                 results, unsafe_requirements, unsafe_packages, markers, hashes
             ):
-                if self.dry_run:
+                if self.dry_run and not self.json_output:
                     # Bypass the log level to always print this during a dry run
-                    log.log(line)
+                    assert isinstance(formatted_req, str)
+                    log.log(formatted_req)
                 else:
                     if not self.json_output:
-                        log.info(line)
-                    dst_file.write(unstyle(line))
-                    dst_file.write("\n")
-                if self.json_output and ireq:
-                    output_structure.append(ireq)
+                        assert isinstance(formatted_req, str)
+                        log.info(formatted_req)
+                        dst_file.write(unstyle(formatted_req))
+                        dst_file.write("\n")
+                    else:
+                        output_structure.append(formatted_req)
         finally:
-            if not self.dry_run or self.json_output:
-                dst_file.detach()
             if self.json_output:
+                json.dump(output_structure, dst_file, indent=4)
                 print(json.dumps(output_structure, indent=4))
+            if not self.dry_run:
+                dst_file.detach()
 
     def _format_requirement(
         self,
@@ -303,7 +309,11 @@ def _format_requirement(
         marker: Marker | None = None,
         hashes: dict[InstallRequirement, set[str]] | None = None,
         unsafe: bool = False,
-    ) -> tuple[str, dict[str, str | list[str]]]:
+    ) -> str | dict[str, str | list[str]]:
+        """Format a given ``InstallRequirement``.
+
+        :returns: A line or a JSON structure to be written to the output file.
+        """
         ireq_hashes = (hashes if hashes is not None else {}).get(ireq)
 
         line = format_requirement(ireq, marker=marker, hashes=ireq_hashes)
@@ -344,36 +354,40 @@ def _format_requirement(
             if self.annotate:
                 line = "\n".join(ln.rstrip() for ln in lines)
 
-        hashable = True
-        if ireq.link:
-            if ireq.link.is_vcs or (ireq.link.is_file and ireq.link.is_existing_dir()):
-                hashable = False
-        output_marker = ""
-        if marker:
-            output_marker = str(marker)
-        via = []
-        for parent_req in required_by:
-            if parent_req.startswith("-r "):
-                # Ensure paths to requirements files given are absolute
-                reqs_in_path = os.path.abspath(parent_req[len("-r ") :])
-                via.append(f"-r {reqs_in_path}")
-            else:
-                via.append(parent_req)
-        output_hashes = []
-        if ireq_hashes:
-            output_hashes = list(ireq_hashes)
-
-        ireq_json = {
-            "name": ireq.name,
-            "version": str(ireq.specifier).lstrip("=="),
-            "requirement": str(ireq.req),
-            "via": via,
-            "line": unstyle(line),
-            "hashable": hashable,
-            "editable": ireq.editable,
-            "hashes": output_hashes,
-            "marker": output_marker,
-            "unsafe": unsafe,
-        }
+        if self.json_output:
+            hashable = True
+            if ireq.link:
+                if ireq.link.is_vcs or (
+                    ireq.link.is_file and ireq.link.is_existing_dir()
+                ):
+                    hashable = False
+            output_marker = ""
+            if marker:
+                output_marker = str(marker)
+            via = []
+            for parent_req in required_by:
+                if parent_req.startswith("-r "):
+                    # Ensure paths to requirements files given are absolute
+                    reqs_in_path = os.path.abspath(parent_req[len("-r ") :])
+                    via.append(f"-r {reqs_in_path}")
+                else:
+                    via.append(parent_req)
+            output_hashes = []
+            if ireq_hashes:
+                output_hashes = list(ireq_hashes)
+
+            ireq_json = {
+                "name": ireq.name,
+                "version": str(ireq.specifier).lstrip("=="),
+                "requirement": str(ireq.req),
+                "via": via,
+                "line": unstyle(line),
+                "hashable": hashable,
+                "editable": ireq.editable,
+                "hashes": output_hashes,
+                "marker": output_marker,
+                "unsafe": unsafe,
+            }
+            return ireq_json
 
-        return line, ireq_json
+        return line

From 77c6d675f55c018bcab611c9bb638a88b46375d3 Mon Sep 17 00:00:00 2001
From: chrysle <96722107+chrysle@users.noreply.github.com>
Date: Thu, 27 Jun 2024 18:25:33 +0200
Subject: [PATCH 4/4] Render temporary `requirements.txt` from
 `requirements.json`

---
 piptools/scripts/compile.py | 10 ++++++++--
 piptools/utils.py           | 16 ++++++++++++++++
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/piptools/scripts/compile.py b/piptools/scripts/compile.py
index ef5d5131..59a2b99f 100755
--- a/piptools/scripts/compile.py
+++ b/piptools/scripts/compile.py
@@ -28,6 +28,7 @@
     install_req_from_line,
     is_pinned_requirement,
     key_from_ireq,
+    render_requirements_json_txt,
 )
 from ..writer import OutputWriter
 from . import options
@@ -309,7 +310,7 @@ def cli(
     # Proxy with a LocalRequirementsRepository if --upgrade is not specified
     # (= default invocation)
     output_file_exists = os.path.exists(output_file.name)
-    if not (upgrade or json) and output_file_exists:
+    if not upgrade and output_file_exists:
         output_file_is_empty = os.path.getsize(output_file.name) == 0
         if upgrade_install_reqs and output_file_is_empty:
             log.warning(
@@ -320,11 +321,16 @@ def cli(
                 "as any existing content is truncated."
             )
 
+        if json:
+            # Render contents of JSON output file to a temporary requirements
+            # file in text format in order to make it readable by ``pip``
+            tmpfile_name = render_requirements_json_txt(output_file.name)
+
         # Use a temporary repository to ensure outdated(removed) options from
         # existing requirements.txt wouldn't get into the current repository.
         tmp_repository = PyPIRepository(pip_args, cache_dir=cache_dir)
         ireqs = parse_requirements(
-            output_file.name,
+            tmpfile_name if json else output_file.name,
             finder=tmp_repository.finder,
             session=tmp_repository.session,
             options=tmp_repository.options,
diff --git a/piptools/utils.py b/piptools/utils.py
index 39a51e92..2e5a016a 100644
--- a/piptools/utils.py
+++ b/piptools/utils.py
@@ -9,6 +9,7 @@
 import re
 import shlex
 import sys
+import tempfile
 from pathlib import Path
 from typing import Any, Callable, Iterable, Iterator, TypeVar, cast
 
@@ -772,3 +773,18 @@ def is_path_relative_to(path1: Path, path2: Path) -> bool:
     except ValueError:
         return False
     return True
+
+
+def render_requirements_json_txt(filename: str) -> str:
+    """Render a given ``requirements.json`` file to a temporary
+    ``requirements.txt`` file and return its name.
+    """
+    with open(filename, encoding="utf-8") as f:
+        reqs = json.load(f)
+    tmpfile = tempfile.NamedTemporaryFile(mode="w+t", encoding="utf-8", delete=False)
+    for req in reqs:
+        tmpfile.write(req["line"])
+        tmpfile.write("\n")
+    tmpfile.flush()
+
+    return tmpfile.name