@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/python/python.ts

@@ -0,0 +1,1934 @@
+import { CCError, has, UTF8encoder } from "../../utils.js";
+import { Word, eq } from "../../shell/Word.js";
+import { parse, COMMON_SUPPORTED_ARGS } from "../../parse.js";
+import type { Request, Warnings } from "../../parse.js";
+import { Headers } from "../../Headers.js";
+import { wordDecodeURIComponent, percentEncode } from "../../Query.js";
+import { DataParam } from "../../Request.js";
+
+import {
+  parse as jsonParseLossless,
+  stringify as jsonStringifyLossless,
+  isSafeNumber,
+  isInteger,
+  isLosslessNumber,
+} from "lossless-json";
+
+// TODO: partiallySupportedArgs
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+
+  "compressed",
+  // "no-compressed",
+
+  // "anyauth",
+  // "no-anyauth",
+  "digest",
+  "no-digest",
+  "aws-sigv4",
+  "negotiate",
+  "no-negotiate",
+  "delegation", // GSS/kerberos
+  // "service-name", // GSS/kerberos, not supported
+  "ntlm",
+  "no-ntlm",
+  "ntlm-wb",
+  "no-ntlm-wb",
+
+  "http1.1",
+  // These are not supported, just better warning message
+  "http2",
+  "http2-prior-knowledge",
+  "http3",
+  "http3-only",
+
+  "cookie-jar",
+
+  "cert",
+  "cacert",
+  "key",
+  "capath",
+
+  "form",
+  "form-string",
+
+  "location",
+  "no-location",
+  "location-trusted", // not exactly supported, just better warning message
+  "no-location-trusted",
+  "max-redirs",
+
+  "max-time",
+  "connect-timeout",
+
+  "insecure",
+  "no-insecure",
+
+  "output",
+  "upload-file",
+
+  "next",
+
+  "proxy",
+  "proxy-user",
+]);
+
+// https://peps.python.org/pep-3138/
+// https://www.unicode.org/reports/tr44/#GC_Values_Table
+// https://unicode.org/Public/UNIDATA/UnicodeData.txt
+// https://en.wikipedia.org/wiki/Plane_(Unicode)#Overview
+const regexSingleEscape = /'|\\|\p{C}|[^ \P{Z}]/gu;
+const regexDoubleEscape = /"|\\|\p{C}|[^ \P{Z}]/gu;
+
+// Also used for Go and R
+export function reprStr(s: string, quote?: '"' | "'"): string {
+  if (quote === undefined) {
+    quote = "'";
+    if (s.includes("'") && !s.includes('"')) {
+      quote = '"';
+    }
+  }
+  const regex = quote === "'" ? regexSingleEscape : regexDoubleEscape;
+
+  return (
+    quote +
+    s.replace(regex, (c: string): string => {
+      switch (c) {
+        case "\x07":
+          return "\\a";
+        case "\b":
+          return "\\b";
+        case "\f":
+          return "\\f";
+        case "\n":
+          return "\\n";
+        case "\r":
+          return "\\r";
+        case "\t":
+          return "\\t";
+        case "\v":
+          return "\\v";
+        case "\\":
+          return "\\\\";
+        case "'":
+          return "\\'";
+        case '"':
+          return '\\"';
+      }
+      const hex = (c.codePointAt(0) as number).toString(16);
+      if (hex.length <= 2) {
+        return "\\x" + hex.padStart(2, "0");
+      }
+      if (hex.length <= 4) {
+        return "\\u" + hex.padStart(4, "0");
+      }
+      return "\\U" + hex.padStart(8, "0");
+    }) +
+    quote
+  );
+}
+
+// TODO: use this if string contains unmatched surrogates?
+// It just replaces them with the replacement character, but at least that code would run.
+export function pybescComplex(s: string): string {
+  let quote = "'";
+  if (s.includes("'") && !s.includes('"')) {
+    quote = '"';
+  }
+  const quoteCode = quote.charCodeAt(0);
+
+  // TODO: using UTF-8 here is overly simplistic and how to encode here
+  // is a pretty complicated decision.
+  // For starters, it would be more correct to use the same encoding as
+  // the terminal when running from the command line.
+  const bytes = UTF8encoder.encode(s);
+
+  return (
+    "b" +
+    quote +
+    [...bytes]
+      .map((c: number): string => {
+        switch (c) {
+          case 0x07:
+            return "\\a";
+          case 0x08:
+            return "\\b";
+          case 0x0c:
+            return "\\f";
+          case 0x0a:
+            return "\\n";
+          case 0x0d:
+            return "\\r";
+          case 0x09:
+            return "\\t";
+          case 0x0b:
+            return "\\v";
+          case 0x5c:
+            return "\\\\";
+          case quoteCode:
+            return "\\" + String.fromCharCode(c);
+        }
+        if (c >= 0x20 && c < 0x7f) {
+          return String.fromCharCode(c);
+        }
+        const hex = c.toString(16);
+        return "\\x" + hex.padStart(2, "0");
+      })
+      .join("") +
+    quote
+  );
+}
+
+export function reprStrBinary(s: string): string {
+  const sEsc = reprStr(s);
+  // We check until 0x7F instead of 0xFF because curl (running in a UTF-8 terminal) when it gets
+  // bytes sends them as is, but if we pass b'\x80' to Requests, it will encode that byte as
+  // Latin-1 (presumably for backwards compatibility) instead of UTF-8.
+  if (/^[\x00-\x7f]*$/.test(s)) {
+    return "b" + sEsc;
+  }
+  // TODO: unmatched surrogates will generate code that throws an error
+  // e.g.: '\uDC00'.encode()
+  return sEsc + ".encode()";
+}
+
+export type OSVars = { [key: string]: string };
+export function repr(
+  word: Word,
+  osVars: OSVars,
+  imports: Set<string>,
+  binary = false,
+  // os.getenv('MYVAR') returns None if MYVAR is not set
+  // os.getenv('MYVAR', '') returns '' if MYVAR is not set but it's a bit more verbose,
+  // so setting errorOk to true will use the shorter version
+  errorOk = false,
+): string {
+  const reprFn = binary ? reprStrBinary : reprStr;
+  const reprs = [];
+  for (const t of word.tokens) {
+    if (typeof t === "string") {
+      reprs.push(reprFn(t));
+    } else if (t.type === "variable") {
+      // TODO: getenvb() is not available on Windows
+      const fn = binary ? "os.getenvb" : "os.getenv";
+      let getEnvCall = fn + "(" + reprFn(t.value);
+      if (!errorOk || word.tokens.length > 1) {
+        getEnvCall += ", " + reprFn("");
+      }
+      getEnvCall += ")";
+      reprs.push(getEnvCall);
+      // TODO: if the result of a repr() is discarded, this adds an unused import
+      imports.add("os");
+    } else if (t.type === "command") {
+      // TODO: warn that shell=True is a bad idea
+      // or properly parse the subcommand and render it as an array
+      let subprocessCall =
+        "subprocess.run(" +
+        reprStr(t.value) +
+        ", shell=True, capture_output=True";
+      if (!binary) {
+        subprocessCall += ", text=True";
+      }
+      subprocessCall += ").stdout";
+
+      // TODO: generate a descriptive command name with ChatGPT
+      // TODO: if there's only one command, name the variable "command" instead of "command1"
+      let i = 1;
+      let pyVar = "command" + i;
+      // We need to check because we often try to represent the same
+      // token twice and discard one of the attempts.
+      // This is linear time but hopefully there's not that many subcommands.
+      while (pyVar in osVars && osVars[pyVar] !== subprocessCall) {
+        i++;
+        pyVar = "command" + i;
+        if (i > Number.MAX_SAFE_INTEGER) {
+          throw new CCError("lol");
+        }
+      }
+      osVars[pyVar] = subprocessCall;
+      reprs.push(pyVar);
+      // TODO: if the result of a repr() is discarded, this adds an unused import
+      imports.add("subprocess");
+    }
+  }
+  return reprs.join(" + ");
+}
+
+function reprb(word: Word, osVars: OSVars, imports: Set<string>): string {
+  return repr(word, osVars, imports, true);
+}
+
+export function asFloat(
+  word: Word,
+  osVars: OSVars,
+  imports: Set<string>,
+): string {
+  if (word.isString()) {
+    // TODO: check it's actually a valid float
+    return word.toString();
+  }
+  return "float(" + repr(word, osVars, imports, false, true) + ")";
+}
+
+export function asInt(
+  word: Word,
+  osVars: OSVars,
+  imports: Set<string>,
+): string {
+  if (word.isString()) {
+    // TODO: check it's actually a valid int
+    return word.toString();
+  }
+  return "int(" + repr(word, osVars, imports, false, true) + ")";
+}
+
+// Port of Python's json.dumps() with its default options, which is what Requests uses
+// https://github.com/psf/requests/blob/b0e025ade7ed30ed53ab61f542779af7e024932e/requests/models.py#L473
+// It's different from JSON.stringify(). Namely, it adds spaces after ',' and ':'
+// and all non-ASCII characters in strings are escaped:
+// > JSON.stringify('\xFF')
+// '"ÿ"'
+// >>> json.dumps('\xFF')
+// '"\\u00ff"'
+const pythonJsonEscape = /"|\\|[^\x20-\x7E]/g;
+function jsonRepr(s: string): string {
+  return (
+    '"' +
+    s.replace(pythonJsonEscape, (c: string): string => {
+      // https://tc39.es/ecma262/#table-json-single-character-escapes
+      switch (c) {
+        case "\b":
+          return "\\b";
+        case "\t":
+          return "\\t";
+        case "\n":
+          return "\\n";
+        case "\f":
+          return "\\f";
+        case "\r":
+          return "\\r";
+        case "\\":
+          return "\\\\";
+        case '"':
+          return '\\"';
+      }
+
+      const hex = c.charCodeAt(0).toString(16);
+      return "\\u" + hex.padStart(4, "0");
+    }) +
+    '"'
+  );
+}
+
+function ensure_minimum_exponent_length(n: string): string {
+  // If there's only 1 exponent digit, add a leading 0 to it
+  // ensure_minimum_exponent_length('1e-7') => '1e-07'
+  const [mantissa, exponent] = n.split("e");
+  const exponentSign = exponent[0];
+  const exponentValue = exponent.slice(1);
+  if (exponentValue.length === 1) {
+    return mantissa + "e" + exponentSign + "0" + exponentValue;
+  }
+  return n;
+}
+function floatAsPython(value: number): string {
+  // JSON.stringify() and lossless-json's stringify() don't stringify floats like Python.
+  // Notably, JavaScript doesn't add a trailing '.0' to floats that are integers but Python does
+  // JSON.stringify(10.0) => '10'
+  // str(10.0)            => '10.0'
+  //
+  // Python adds a leading 0 to exponent notation numbers with 1 exponent digit
+  // JSON.stringify(1e-7) => '1e-7'
+  //            str(1e-7) => '1e-07'
+  //
+  // Finally, Python will switch to scientific notation if the number has more than
+  // 17 digits not in scientific notation.
+  //
+  // Python's float formatting starts here:
+  // https://github.com/python/cpython/blob/bdc93b8a3563b4a3adb25fa902c0c879ccf427f6/Python/pystrtod.c#L915-L918
+  // and is ultimately this code:
+  // snprintf(buf, buf_size, "%.17g", val)
+  // change_decimal_from_locale_to_dot(buffer); // not important
+  // ensure_minimum_exponent_length(buffer, buf_size);
+  // ensure_decimal_point(buffer, buf_size, 17); // can switch to exponent notation
+  //
+  // And JavaScript's formatting is specified here:
+  // https://tc39.es/ecma262/multipage/ecmascript-data-types-and-values.html#sec-numeric-types-number-tostring
+  let asJsStr = value.toString();
+  if (asJsStr.includes("e")) {
+    asJsStr = ensure_minimum_exponent_length(asJsStr);
+  } else {
+    if (isInteger(asJsStr)) {
+      asJsStr += ".0";
+    }
+    // If there's more than 17 digits of precision, switch to scientific notation
+    const significantDigits = asJsStr
+      .replace(/^-/, "")
+      .replace(".", "")
+      .replace(/^0+/, "");
+    const asExponential = ensure_minimum_exponent_length(value.toExponential());
+    if (
+      significantDigits.length > 17 ||
+      (asExponential.length < asJsStr.length &&
+        asJsStr.split(".")[1].length > 4)
+    ) {
+      asJsStr = asExponential;
+    }
+  }
+  return asJsStr;
+}
+
+function jsonDumps(obj: string | number | boolean | object | null): string {
+  if (isLosslessNumber(obj)) {
+    const numAsStr = jsonStringifyLossless(obj) as string;
+    if (isInteger(numAsStr)) {
+      return numAsStr;
+    }
+
+    if (!isSafeNumber(numAsStr)) {
+      throw new CCError("float unrepresentable in Python: " + numAsStr);
+    }
+    // Can't be bigint because it's !isInteger and isSafeNumber
+    return floatAsPython(obj.valueOf() as number);
+  }
+
+  switch (typeof obj) {
+    case "string":
+      return jsonRepr(obj);
+    case "number":
+      // If the number in the JSON file is very large, it'll turn into Infinity
+      if (!isFinite(obj)) {
+        throw new CCError("found Infitiny in JSON");
+      }
+      // TODO: If the number in the JSON file is too big for JavaScript, we will lose information
+      // TODO: JavaScript and Python serialize floats differently.
+      // JSON.stringify(2e2) => 200
+      // json.dumps(2e2)     => 200.0
+      return obj.toString();
+    case "boolean":
+      return obj.toString();
+    case "object":
+      if (obj === null) {
+        return "null";
+      }
+      if (Array.isArray(obj)) {
+        return "[" + obj.map(jsonDumps).join(", ") + "]";
+      }
+      return (
+        "{" +
+        Object.entries(obj)
+          .map((e) => jsonRepr(e[0]) + ": " + jsonDumps(e[1]))
+          .join(", ") +
+        "}"
+      );
+    default:
+      throw new CCError(
+        "unexpected object type that shouldn't appear in JSON: " + typeof obj,
+      );
+  }
+}
+
+function objToPython(
+  obj: string | number | boolean | object | null,
+  indent = 0,
+): string {
+  if (isLosslessNumber(obj)) {
+    const numAsStr = jsonStringifyLossless(obj) as string;
+    // If the number is a large float, it might not be representable in Python
+    // Both JavaScript and Python use f64 so we check if the float
+    // is representable in JavaScript.
+    if (!isInteger(numAsStr) && !isSafeNumber(numAsStr)) {
+      throw new CCError("float unrepresentable in Python: " + numAsStr);
+    }
+    // Displaying floats as they will be serialized in Python would help users
+    // understand why they're getting the "JSON won't be serialized as it was originally"
+    // message, but I think displaying them as they appear in the JSON is likely
+    // to be more convenient if you need to edit the value.
+    return numAsStr;
+  }
+
+  switch (typeof obj) {
+    case "string":
+      return reprStr(obj);
+    case "number":
+      // TODO: there are differences in number serialization between Python and JavaScript
+      // TODO: if the number in the JSON file is too big for JavaScript, we will lose information
+      return obj.toString();
+    case "boolean":
+      return obj ? "True" : "False";
+    case "object":
+      if (obj === null) {
+        return "None";
+      }
+      if (Array.isArray(obj)) {
+        if (obj.length === 0) {
+          return "[]";
+        }
+        let s = "[\n";
+        for (const item of obj) {
+          s += " ".repeat(indent + 4) + objToPython(item, indent + 4) + ",\n";
+        }
+        s += " ".repeat(indent) + "]";
+        return s;
+      }
+
+      if (Object.keys(obj).length === 0) {
+        return "{}";
+      }
+      {
+        let s = "{\n";
+        for (const [k, v] of Object.entries(obj)) {
+          // repr() because JSON keys must be strings.
+          s +=
+            " ".repeat(indent + 4) +
+            reprStr(k) +
+            ": " +
+            objToPython(v, indent + 4) +
+            ",\n";
+        }
+        s += " ".repeat(indent) + "}";
+        return s;
+      }
+    default:
+      throw new CCError(
+        "unexpected object type that shouldn't appear in JSON: " + typeof obj,
+      );
+  }
+}
+
+export function formatHeaders(
+  headers: Headers,
+  commentedOutHeaders: { [key: string]: string },
+  osVars: OSVars,
+  imports: Set<string>,
+): string {
+  // TODO: what if there are repeat headers
+  let headerDict = "headers = {\n";
+  for (const [headerName, headerValue] of headers) {
+    if (headerValue === null) {
+      continue;
+    }
+
+    let lineStart;
+    const headerNameLower = headerName.toLowerCase().toString();
+    if (has(commentedOutHeaders, headerNameLower)) {
+      if (commentedOutHeaders[headerNameLower]) {
+        headerDict += "    # " + commentedOutHeaders[headerNameLower] + "\n";
+      }
+      lineStart = "    # ";
+    } else {
+      lineStart = "    ";
+    }
+    headerDict +=
+      lineStart +
+      repr(headerName, osVars, imports) +
+      ": " +
+      repr(headerValue, osVars, imports) +
+      ",\n";
+  }
+  headerDict += "}\n";
+  return headerDict;
+}
+
+function decodePercentEncoding(s: Word): Word | null {
+  let decoded;
+  try {
+    // https://url.spec.whatwg.org/#urlencoded-parsing recommends replacing + with space
+    // before decoding.
+    decoded = wordDecodeURIComponent(s.replace(/\+/g, " "));
+  } catch (e) {
+    if (e instanceof URIError) {
+      // String contains invalid percent encoded characters
+      return null;
+    }
+    throw e;
+  }
+  // If the query string doesn't round-trip, we cannot properly convert it.
+  const roundTripKey = percentEncode(decoded);
+  // If the original data used %20 instead of + (what requests will send), that's close enough
+  if (!eq(roundTripKey, s) && !eq(roundTripKey.replace(/%20/g, "+"), s)) {
+    return null;
+  }
+  return decoded;
+}
+
+function dataEntriesToDict(
+  dataEntries: Array<[string, string]>,
+): { [key: string]: Array<string> } | null {
+  // Group keys
+  // TODO: because keys can be code that reads from a file, those should not be considered the
+  // same key, for example what if that file is /dev/urandom.
+  // TODO: would we need to distinguish if /dev/urandom came from @/dev/urandom or from @-?
+  const asDict: { [key: string]: Array<string> } = {};
+  let prevKey = null;
+  for (const [key, val] of dataEntries) {
+    if (prevKey === key) {
+      asDict[key].push(val);
+    } else {
+      if (!Object.prototype.hasOwnProperty.call(asDict, key)) {
+        asDict[key] = [val];
+      } else {
+        // A repeated key with a different key between one of its repetitions
+        // means we can't represent these entries as a dictionary.
+        return null;
+      }
+    }
+    prevKey = key;
+  }
+
+  return asDict;
+}
+
+function dataEntriesToPython(dataEntries: Array<[string, string]>): string {
+  if (dataEntries.length === 0) {
+    return "''"; // This shouldn't happen
+  }
+
+  const entriesDict = dataEntriesToDict(dataEntries);
+  if (entriesDict !== null) {
+    if (Object.keys(entriesDict).length === 0) {
+      return "''"; // This shouldn't happen
+    }
+    let s = "{\n";
+    for (const [key, vals] of Object.entries(entriesDict)) {
+      s += "    " + key + ": ";
+      if (vals.length === 0) {
+        s += "''"; // This shouldn't happen
+      } else if (vals.length === 1) {
+        s += vals[0];
+      } else {
+        s += "[\n";
+        for (const val of vals) {
+          s += "        " + val + ",\n";
+        }
+        s += "    ]";
+      }
+      s += ",\n";
+    }
+    s += "}";
+    return s;
+  }
+
+  let s = "[\n";
+  for (const entry of dataEntries) {
+    const [key, val] = entry;
+    s += "    (" + key + ", " + val + "),\n";
+  }
+  s += "]";
+  return s;
+}
+
+function formatDataAsEntries(
+  dataArray: DataParam[],
+  osVars: OSVars,
+  imports: Set<string>,
+  variableName: "data" | "params" = "data",
+): [string, string] | null {
+  // This code is more complicated than you might expect because it needs
+  // to handle a --data-urlencode that reads from a file followed by --json
+  // because --json doesn't add an '&' before its value.  Specifically, we
+  // have these cases:
+  //
+  // --data-urlencode @filename --json =value
+  // {open('filename').read(): 'value'}
+  //
+  // --data-urlencode @filename --json key=value
+  // {open('filename').read() + 'key': 'value'}
+  //
+  // --data-urlencode @filename --json key
+  // error
+  //
+  // --data-urlencode name@filename --json value
+  // {'name': open('filename').read() + 'value'}
+  //
+  // --data-urlencode name@filename --json key=value
+  // error
+  //
+  // --data-urlencode name@filename --json =blah
+  // error
+  //
+  // --data-urlencode adds an '&' before its value, so we don't have to worry about
+  // --json <foo> --data-urlencode <bar>
+  for (const d of dataArray) {
+    if (!(d instanceof Word) && d.filetype !== "urlencode") {
+      return null;
+    }
+  }
+
+  const dataEntries: Array<[string, string | null]> = [];
+  let percentWarn = new Word();
+  for (const [i, d] of dataArray.entries()) {
+    if (d instanceof Word) {
+      let newEntries = d.split("&");
+
+      const prevEntry = i > 0 ? dataEntries[dataEntries.length - 1] : null;
+      if (prevEntry !== null) {
+        // If there's a prevEntry, we can assume it came from --data-urlencode
+        // because it would be part of the current `d` string if it didn't.
+        const [first, ...rest] = newEntries;
+        if (first.includes("=") && prevEntry[1] === null) {
+          const [key, val] = first.split("=", 2);
+          const decodedKey = decodePercentEncoding(key);
+          if (decodedKey === null) {
+            return null;
+          }
+          const decodedVal = decodePercentEncoding(val);
+          if (decodedVal === null) {
+            return null;
+          }
+          if (key.toBool()) {
+            prevEntry[0] += " + " + repr(decodedKey, osVars, imports);
+          }
+          prevEntry[1] = repr(decodedVal, osVars, imports);
+
+          if (!percentWarn.toBool()) {
+            if (key.includes("%20")) {
+              percentWarn = key;
+            }
+            if (val.includes("%20")) {
+              percentWarn = val;
+            }
+          }
+        } else if (!first.includes("=") && prevEntry[1] !== null) {
+          if (first.toBool()) {
+            const decodedVal = decodePercentEncoding(first);
+            if (decodedVal === null) {
+              return null;
+            }
+            prevEntry[1] += " + " + repr(decodedVal, osVars, imports);
+
+            if (!percentWarn.toBool() && first.includes("%20")) {
+              percentWarn = first;
+            }
+          }
+        } else {
+          return null;
+        }
+        newEntries = rest;
+      }
+
+      for (const [j, entry] of newEntries.entries()) {
+        if (
+          entry.isEmpty() &&
+          j === newEntries.length - 1 &&
+          i !== dataArray.length - 1
+        ) {
+          // A --data-urlencoded should come next
+          continue;
+        }
+        if (!entry.includes("=")) {
+          return null;
+        }
+        const [key, val] = entry.split("=", 2);
+        const decodedKey = decodePercentEncoding(key);
+        if (decodedKey === null) {
+          return null;
+        }
+        const decodedVal = decodePercentEncoding(val);
+        if (decodedVal === null) {
+          return null;
+        }
+        dataEntries.push([
+          repr(decodedKey, osVars, imports),
+          repr(decodedVal, osVars, imports),
+        ]);
+
+        if (!percentWarn.toBool()) {
+          if (key.includes("%20")) {
+            percentWarn = key;
+          }
+          if (val.includes("%20")) {
+            percentWarn = val;
+          }
+        }
+      }
+
+      continue;
+    }
+
+    // TODO: I bet Python doesn't treat file paths identically to curl
+    const readFile = eq(d.filename, "-")
+      ? "sys.stdin.read()"
+      : "open(" + repr(d.filename, osVars, imports, false, true) + ").read()";
+
+    if (!d.name) {
+      dataEntries.push([readFile, null]);
+    } else {
+      // Curl doesn't percent encode the name but Requests will
+      if (!eq(d.name, percentEncode(d.name))) {
+        return null;
+      }
+      dataEntries.push([repr(d.name, osVars, imports), readFile]);
+    }
+  }
+
+  if (dataEntries.some((e) => e[1] === null)) {
+    return null;
+  }
+
+  return [
+    variableName +
+      " = " +
+      dataEntriesToPython(dataEntries as [string, string][]) +
+      "\n",
+    percentWarn.toString(),
+  ];
+}
+
+function formatDataAsStr(
+  dataArray: DataParam[],
+  imports: Set<string>,
+  osVars: OSVars,
+  variableName: "data" | "params" = "data",
+): [string, boolean] {
+  // If one of the arguments has to be binary, then they all have to be binary
+  // because we can't mix bytes and str.
+  // An argument has to be binary when the input command has
+  // --data-binary @filename
+  // otherwise we could generate code that will try to read an image file as text and error.
+  const binary = dataArray.some(
+    (d) => !(d instanceof Word) && d.filetype === "binary",
+  );
+  const reprFunc = binary ? reprb : repr;
+  const prefix = binary ? "b" : "";
+  const mode = binary ? ", 'rb'" : "";
+
+  // If we see a string with non-ASCII characters, or read from a file (which may contain
+  // non-ASCII characters), we convert the entire string to bytes at the end.
+  // curl sends bytes as-is, which is presumably in UTF-8, whereas Requests sends
+  // 0x80-0xFF as Latin-1 (as-is) and throws an error if it sees codepoints
+  // above 0xFF.
+  // TODO: is this actually helpful?
+  let encode = false;
+  let encodeOnSeparateLine = false;
+
+  const lines = [];
+
+  let extra = new Word();
+  let i, d;
+  for ([i, d] of dataArray.entries()) {
+    const op = i === 0 ? "=" : "+=";
+    let line = variableName + " " + op + " ";
+
+    if (i < dataArray.length - 1 && d instanceof Word && d.endsWith("&")) {
+      // Put the trailing '&' on the next line so that we don't have single '&'s on their own lines
+      extra = new Word("&");
+      d = d.slice(0, -1);
+    }
+
+    if (d instanceof Word) {
+      if (d.length) {
+        line += reprFunc(d, osVars, imports);
+        lines.push(line);
+        encode ||= d.test(/[^\x00-\x7F]/);
+      }
+      continue;
+    }
+
+    const { filetype, name, filename } = d;
+    if (filetype === "urlencode" && name) {
+      line += reprFunc(extra.add(name).append("="), osVars, imports) + " + ";
+      encodeOnSeparateLine = true; // we would need to add parentheses because of the +
+    } else if (extra.toBool()) {
+      line += reprFunc(extra, osVars, imports) + " + ";
+      encodeOnSeparateLine = true;
+    }
+    if (extra.toBool()) {
+      encodeOnSeparateLine = true; // we would need to add parentheses because of the +
+    }
+
+    let readFile = "";
+    if (eq(filename, "-")) {
+      readFile += binary ? "sys.stdin.buffer" : "sys.stdin";
+      imports.add("sys");
+    } else {
+      // TODO: if filename is a command, this won't work because unlike bash,
+      // Python won't remove the trailing newline from the result of a command
+      // we need to add .trim()
+      line =
+        "with open(" +
+        repr(filename, osVars, imports, false, true) +
+        mode +
+        ") as f:\n    " +
+        line;
+      readFile += "f";
+    }
+    readFile += ".read()";
+    if (!["binary", "json", "urlencode"].includes(filetype)) {
+      readFile += `.replace(${prefix}'\\n', ${prefix}'').replace(${prefix}'\\r', ${prefix}'')`;
+    }
+
+    if (filetype === "urlencode") {
+      readFile = "quote_plus(" + readFile + ")";
+      if (binary) {
+        // quote_plus() always returns a string
+        readFile += ".encode()";
+      }
+      imports.add("urllib.parse.quote_plus");
+    } else {
+      // --data-urlencode files don't need to be encoded because
+      // they'll be percent-encoded and therefore ASCII-only
+      encode = true;
+    }
+
+    line += readFile;
+    lines.push(line);
+    extra = new Word();
+  }
+
+  if (binary) {
+    encode = false;
+  } else if (encode && lines.length === 1 && !encodeOnSeparateLine) {
+    lines[lines.length - 1] += ".encode()";
+    encode = false;
+  }
+
+  return [lines.join("\n") + "\n", encode];
+}
+
+export function formatDataAsJson(
+  d: DataParam,
+  imports: Set<string>,
+  osVars: OSVars,
+): [string | null, boolean] {
+  if (d instanceof Word) {
+    if (!d.isString()) {
+      // TODO: a JSON parser that allows shell variables
+      return [null, false];
+    }
+
+    // Try to parse using lossless-json first, then fall back to JSON.parse
+    // TODO: repeated dictionary keys are discarded
+    // https://github.com/josdejong/lossless-json/issues/244
+    let dataAsJson;
+    try {
+      // TODO: types
+      // https://github.com/josdejong/lossless-json/issues/245
+      dataAsJson = jsonParseLossless(d.toString()) as any;
+    } catch {
+      try {
+        dataAsJson = JSON.parse(d.toString());
+      } catch {
+        return [null, false];
+      }
+    }
+
+    try {
+      const jsonDataString = "json_data = " + objToPython(dataAsJson) + "\n";
+      // JSON might not be serialized by Python exactly as it was originally
+      // due to different whitespace, float formatting like extra + in exponent
+      // (1e100 vs 1e+100), different escape sequences in strings
+      // ("\/" vs "/" or "\u0008" vs "\b") or duplicate object keys.
+      let jsonRoundtrips = false;
+      try {
+        jsonRoundtrips = jsonDumps(dataAsJson) === d.tokens[0];
+      } catch {}
+      return [jsonDataString, jsonRoundtrips];
+    } catch {}
+  } else if (d.filetype === "json") {
+    let jsonDataString = "";
+    jsonDataString +=
+      "with open(" +
+      repr(d.filename, osVars, imports, false, true) +
+      ") as f:\n";
+    jsonDataString += "    json_data = json.load(f)\n";
+    imports.add("json");
+    return [jsonDataString, false];
+  }
+
+  return [null, false];
+}
+
+function getDataString(
+  request: Request,
+  osVars: OSVars,
+  warnings: Warnings,
+): [string | null, boolean | null, string | null, Set<string>] {
+  const imports = new Set<string>();
+  if (!request.data || !request.dataArray) {
+    return [null, false, null, imports];
+  }
+
+  // There's 4 ways to pass data to Requests (in descending order of preference):
+  //   a or dictionary/list as the json= argument
+  //   a dictionary, or a list of tuples (if the dictionary would have duplicate keys) as the data= argument
+  //   a string as data=
+  //   bytes as data=
+
+  // We can pass json= if the data is valid JSON and we've specified json in the
+  // Content-Type header because passing json= will set that header.
+  //
+  // However, if there will be a mismatch between how the JSON is formatted
+  // we need to output a commented out version of the request with data= as well.
+  // This can happen when there's extra whitespace in the original data or
+  // because the JSON contains numbers that are too big to be stored in
+  // JavaScript or because there's objects with duplicate keys.
+  const contentType = request.headers.get("content-type");
+  let dataAsJson: string | null = null;
+  let jsonRoundtrips = false;
+  if (
+    request.dataArray.length === 1 &&
+    contentType &&
+    contentType.split(";")[0].toString().trim() === "application/json"
+  ) {
+    [dataAsJson, jsonRoundtrips] = formatDataAsJson(
+      request.dataArray[0],
+      imports,
+      osVars,
+    );
+  }
+  if (jsonRoundtrips) {
+    return [null, false, dataAsJson, imports];
+  }
+
+  // data= can't be a dict or a list of tuples (i.e. entries) when
+  //   there is a @file from --data, --data-binary or --json (because they can contain an '&' which would get escaped)
+  //   there is a --data-urlencode without a name= or name@
+  //   if you split the input on & and there's a value that doesn't contain an = (e.g. --data "foo=bar&" or simply --data "&")
+  //   there is a name or value that doesn't roundtrip through percent encoding
+  const dataAsEntries = formatDataAsEntries(request.dataArray, osVars, imports);
+  if (dataAsEntries !== null) {
+    const [dataEntries, percentWarn] = dataAsEntries;
+    if (
+      eq(
+        request.headers.get("content-type"),
+        "application/x-www-form-urlencoded",
+      ) &&
+      request.headers.length === 1
+    ) {
+      // Requests adds the header when you include a body
+      // so if it's the only header, don't print the headers
+      request.headers.delete("content-type");
+    }
+    if (percentWarn) {
+      warnings.push([
+        "percent-encoded-spaces-in-data",
+        'data contains spaces encoded by curl as "%20" which will be sent as "+" instead: ' +
+          JSON.stringify(percentWarn),
+      ]);
+    }
+    return [dataEntries, false, dataAsJson, imports];
+  }
+
+  const [dataAsString, shouldEncode] = formatDataAsStr(
+    request.dataArray,
+    imports,
+    osVars,
+  );
+  return [dataAsString, shouldEncode, dataAsJson, imports];
+}
+
+function getFilesString(
+  request: Request,
+  osVars: OSVars,
+  imports: Set<string>,
+): [string, boolean] {
+  let usesStdin = false;
+  if (!request.multipartUploads) {
+    return ["", usesStdin];
+  }
+
+  const multipartUploads = request.multipartUploads.map((m) => {
+    // https://github.com/psf/requests/blob/2d5517682b3b38547634d153cea43d48fbc8cdb5/requests/models.py#L117
+    //
+    // Requests's multipart syntax looks like this:
+    // name/filename: content
+    // name: open(filename/contentFile)
+    // name: (filename, open(contentFile)[, contentType[, headers]]))
+    const name = m.name ? repr(m.name, osVars, imports) : "None";
+
+    if (!("contentType" in m) && !("headers" in m) && !("encoder" in m)) {
+      if (
+        "contentFile" in m &&
+        eq(m.contentFile, m.filename) &&
+        !eq(m.contentFile, "-")
+      ) {
+        return [
+          name,
+          "open(" +
+            repr(m.contentFile, osVars, imports, false, true) +
+            ", 'rb')",
+        ];
+      }
+      if ("content" in m && "filename" in m && eq(m.name, m.filename)) {
+        return [name, repr(m.content, osVars, imports)];
+      }
+    }
+
+    const sentFilename =
+      "filename" in m && m.filename
+        ? repr(m.filename, osVars, imports)
+        : "None";
+    const tuple = [sentFilename];
+    if ("contentFile" in m) {
+      if (eq(m.contentFile, "-")) {
+        // TODO: use piped stdin if we have it
+        usesStdin = true;
+        tuple.push("sys.stdin.buffer.read())");
+      } else {
+        tuple.push(
+          "open(" +
+            repr(m.contentFile, osVars, imports, false, true) +
+            ", 'rb')",
+        );
+      }
+    } else {
+      tuple.push(repr(m.content, osVars, imports));
+    }
+    let addedContentType = false;
+    if ("contentType" in m && m.contentType) {
+      tuple.push(repr(m.contentType, osVars, imports));
+      addedContentType = true;
+    }
+    if (
+      ("headers" in m && m.headers) ||
+      ("headerFiles" in m && m.headerFiles)
+    ) {
+      if (!addedContentType) {
+        tuple.push("None");
+      }
+
+      const headerArg = [];
+      if (m.headers) {
+        let headerDict = "{";
+        for (const header of m.headers) {
+          // TODO: can have multiple headers in one headers= argument?
+          const [name, value] = header.split(":", 2);
+          headerDict +=
+            repr(name, osVars, imports) +
+            ": " +
+            repr(value.trimStart() || new Word(), osVars, imports) +
+            ", ";
+        }
+        if (headerDict.endsWith(", ")) {
+          headerDict = headerDict.slice(0, -2);
+        }
+        headerDict += "}";
+        headerArg.push(headerDict);
+      }
+      if (m.headerFiles && m.headerFiles.length) {
+        for (const headerFile of m.headerFiles) {
+          headerArg.push(
+            "read_headerfile(" +
+              repr(headerFile, osVars, imports, false, true) +
+              ")",
+          );
+        }
+        imports.add("read_headerfile");
+      }
+      tuple.push(headerArg.join(" | "));
+    }
+    return [name, "(" + tuple.join(", ") + ")"];
+  });
+
+  const multipartUploadsAsDict = Object.fromEntries(multipartUploads);
+
+  let filesString = "files = ";
+  if (Object.keys(multipartUploadsAsDict).length === multipartUploads.length) {
+    filesString += "{\n";
+    for (const [multipartKey, multipartValue] of multipartUploads) {
+      filesString += "    " + multipartKey + ": " + multipartValue + ",\n";
+    }
+    filesString += "}\n";
+  } else {
+    filesString += "[\n";
+    for (const [multipartKey, multipartValue] of multipartUploads) {
+      filesString += "    (" + multipartKey + ", " + multipartValue + "),\n";
+    }
+    filesString += "]\n";
+  }
+
+  return [filesString, usesStdin];
+}
+
+// Don't add indent/comment characters to empty lines, most importantly the last line
+// which will be empty when there's a trailing newline.
+function indent(s: string, level: number) {
+  if (level === 0) {
+    return s;
+  }
+  const begin = "    ".repeat(level);
+  return s
+    .split("\n")
+    .map((l) => (l.trim() ? begin + l : l))
+    .join("\n");
+}
+function commentOut(s: string) {
+  return s
+    .split("\n")
+    .map((l) => (l.trim() ? "#" + l : l))
+    .join("\n");
+}
+
+function uniqueWarn(
+  seenWarnings: Set<string>,
+  warnings: Warnings,
+  warning: [string, string],
+) {
+  if (!seenWarnings.has(warning[0])) {
+    seenWarnings.add(warning[0]);
+    warnings.push(warning);
+  }
+}
+
+function joinArgs(args: string[]) {
+  let s = "(";
+  if (args.join("").length < 100) {
+    s += args.join(", ");
+  } else {
+    s += "\n";
+    for (const arg of args) {
+      s += "    " + arg + ",\n";
+    }
+  }
+  return s + ")";
+}
+
+function requestToPython(
+  request: Request,
+  warnings: Warnings = [],
+  imports: Set<string>,
+  thirdPartyImports: Set<string>,
+): string {
+  const osVars: OSVars = {};
+  const commentedOutHeaders: { [key: string]: string } = {
+    // TODO: add a warning why this should be commented out?
+    "accept-encoding": "",
+    "content-length": "",
+  };
+  // https://github.com/icing/blog/blob/main/curl_on_a_weekend.md
+  if (eq(request.headers.get("te"), "trailers")) {
+    commentedOutHeaders.te = "Requests doesn't support trailers";
+  }
+
+  let cookieStr;
+  let cookieFile: Word | null = null;
+  if (request.cookies) {
+    // TODO: handle duplicate cookie names
+    cookieStr = "cookies = {\n";
+    for (const [cookieName, cookieValue] of request.cookies) {
+      cookieStr +=
+        "    " +
+        repr(cookieName, osVars, imports) +
+        ": " +
+        repr(cookieValue, osVars, imports) +
+        ",\n";
+    }
+    cookieStr += "}\n";
+    // Before Python 3.11, cookies= was sorted alphabetically
+    // https://github.com/python/cpython/issues/86232
+    commentedOutHeaders.cookie = "";
+    if (request.cookieFiles) {
+      warnings.push([
+        "cookie-files",
+        "passing both cookies and cookie files with --cookie/-b is not supported",
+      ]);
+    }
+    if (request.cookieJar) {
+      warnings.push([
+        "cookie-files",
+        "passing both cookies and --cookie-jar/-c is not supported",
+      ]);
+    }
+  } else if (
+    (request.cookieFiles && request.cookieFiles.length) ||
+    request.cookieJar
+  ) {
+    imports.add("http.cookiejar.MozillaCookieJar");
+    if (request.cookieFiles && request.cookieFiles.length) {
+      // TODO: what if user passes multiple cookie files?
+      // TODO: what if user passes cookies and cookie files?
+      cookieFile = request.cookieFiles[request.cookieFiles.length - 1];
+      if (request.cookieFiles.length > 1) {
+        warnings.push([
+          "cookie-files",
+          // TODO: curl reads all of them.
+          "multiple cookie files are not supported, using the last one: " +
+            JSON.stringify(cookieFile.toString()),
+        ]);
+      }
+      // TODO: do we need to .load()?
+      cookieStr =
+        "cookies = MozillaCookieJar(" +
+        repr(cookieFile, osVars, imports) +
+        ")\n";
+    } else if (request.cookieJar) {
+      cookieStr = "cookies = MozillaCookieJar()\n";
+    }
+  }
+
+  let proxyDict;
+  if (request.proxy) {
+    let proxy = request.proxy.includes("://")
+      ? request.proxy
+      : request.proxy.prepend("http://");
+    const protocol = proxy.split("://")[0].toLowerCase();
+    if (eq(protocol, "socks")) {
+      // https://github.com/curl/curl/blob/curl-7_86_0/lib/url.c#L2418-L2419
+      proxy = proxy.replace("socks", "socks4");
+    }
+    proxyDict = "proxies = {\n";
+    proxyDict += "    'http': " + repr(proxy, osVars, imports) + ",\n";
+    // TODO: if (protocol !== "http") { ?
+    proxyDict += "    'https': " + repr(proxy, osVars, imports) + ",\n";
+    proxyDict += "}\n";
+  }
+
+  let certStr;
+  if (request.cert || request.key) {
+    certStr = "cert = ";
+    let certPart = "None";
+    if (request.cert) {
+      const [cert, password] = request.cert;
+      certPart = repr(cert, osVars, imports);
+      if (password) {
+        warnings.push([
+          "cert-password",
+          "passing a password to --cert is not supported: " +
+            JSON.stringify(password.toString()),
+        ]);
+      }
+    }
+    if (request.key) {
+      certStr +=
+        "(" + certPart + ", " + repr(request.key, osVars, imports) + ")";
+    } else {
+      certStr += certPart;
+    }
+    certStr += "\n";
+  }
+
+  // if there's only 1 URL, put params all together here, unless it's just one string.
+  // if there's more than 1, if we have params that are added to each URL from
+  // --get --data or --url-query that need to read a file, put just the shared part
+  // here, then keep the query in the URL, in the URL.
+  // If there's no --get --data or --url-query, then
+  // put params (if it can be rendered as a list or dict) right before the requests line
+  // Otherwise, keep the query in the URL.
+  let paramsStr;
+  let shouldEncodeParams; // TODO: necessary?
+  function readsFile(paramArray: DataParam[]) {
+    return paramArray.some((p) => !(p instanceof Word));
+  }
+  const paramArray =
+    request.urls.length === 1 ? request.urls[0].queryArray : request.queryArray;
+  if (
+    paramArray &&
+    (request.urls.length === 1 ||
+      (request.urls.length > 1 && readsFile(paramArray)))
+  ) {
+    const queryAsEntries = formatDataAsEntries(
+      paramArray,
+      osVars,
+      imports,
+      "params",
+    );
+    if (queryAsEntries !== null) {
+      let percentWarn;
+      [paramsStr, percentWarn] = queryAsEntries;
+
+      if (percentWarn) {
+        warnings.push([
+          "percent-encoded-spaces-in-query",
+          // TODO: will they?
+          'URL querystring contains spaces encoded as "%20" which will be sent by Requests as "+" instead: ' +
+            JSON.stringify(percentWarn),
+        ]);
+      }
+    } else if (readsFile(paramArray)) {
+      [paramsStr, shouldEncodeParams] = formatDataAsStr(
+        paramArray,
+        imports,
+        osVars,
+        "params",
+      );
+    }
+  }
+
+  const contentType = request.headers.get("content-type");
+  let dataString;
+  let jsonDataString;
+  let filesString;
+  let shouldEncode;
+  if (request.urls[0].uploadFile && request.urls.length === 1) {
+    // TODO: https://docs.python-requests.org/en/latest/user/advanced/#streaming-uploads
+    if (
+      eq(request.urls[0].uploadFile, "-") ||
+      eq(request.urls[0].uploadFile, ".")
+    ) {
+      dataString = "data = sys.stdin.buffer.read()\n";
+      imports.add("sys");
+    } else {
+      dataString =
+        "with open(" +
+        repr(request.urls[0].uploadFile, osVars, imports, false, true) +
+        ", 'rb') as f:\n";
+      dataString += "    data = f.read()\n";
+    }
+  } else if (request.multipartUploads) {
+    let usesStdin = false;
+    [filesString, usesStdin] = getFilesString(request, osVars, imports);
+    if (usesStdin) {
+      imports.add("sys");
+    }
+    // If you pass files= then Requests adds this header and a `boundary`
+    // If you manually pass a Content-Type header it won't set a `boundary`
+    // wheras curl does, so the request will fail.
+    // https://github.com/curlconverter/curlconverter/issues/248
+    if (
+      filesString &&
+      contentType &&
+      eq(contentType.trim(), "multipart/form-data") &&
+      !contentType.includes("boundary=")
+    ) {
+      // TODO: better wording
+      commentedOutHeaders["content-type"] =
+        "requests won't add a boundary if this header is set when you pass files=";
+    }
+  } else if (request.data && !request.data.isEmpty()) {
+    // !isEmpty() because passing data='' is the same as not passing data=
+    // We need to set the Content-Type header in headers= and not set data=
+    let dataImports: Set<string>;
+    [dataString, shouldEncode, jsonDataString, dataImports] = getDataString(
+      request,
+      osVars,
+      warnings,
+    );
+    dataImports.forEach(imports.add, imports);
+    // Remove "Content-Type" from the headers dict
+    // because Requests adds it automatically when you use json=
+    if (
+      jsonDataString &&
+      !dataString &&
+      contentType &&
+      eq(contentType.trim(), "application/json")
+    ) {
+      commentedOutHeaders["content-type"] = "Already added when you pass json=";
+    }
+  }
+
+  let headerDict;
+  if (request.headers.length) {
+    headerDict = formatHeaders(
+      request.headers,
+      commentedOutHeaders,
+      osVars,
+      imports,
+    );
+  }
+
+  let pythonCode = "";
+
+  if (proxyDict) {
+    pythonCode += proxyDict + "\n";
+  }
+  if (cookieStr) {
+    pythonCode += cookieStr + "\n";
+  }
+  if (headerDict) {
+    pythonCode += headerDict + "\n";
+  }
+  if (paramsStr) {
+    pythonCode += paramsStr + "\n";
+  }
+  if (certStr) {
+    pythonCode += certStr + "\n";
+  }
+  if (jsonDataString) {
+    pythonCode += jsonDataString + "\n";
+  } else if (dataString) {
+    pythonCode += dataString + "\n";
+  } else if (filesString) {
+    pythonCode += filesString + "\n";
+  }
+
+  // By default, curl doesn't follow redirects and Requests does.
+  // Unless redirect behavior has been explicitly set with -L/--location/--no-location
+  // or --max-redirs 0 we pretend generate code that follows redirects,
+  // because adding allow_redirects=False to almost every command would be ugly
+  // and it only matters when the server responds with a redirect, which isn't
+  // that common.
+  let followRedirects = request.followRedirects;
+  let maxRedirects = undefined;
+  if (request.maxRedirects !== undefined) {
+    maxRedirects = asInt(request.maxRedirects, osVars, imports);
+  }
+  if (followRedirects === undefined) {
+    followRedirects = true;
+
+    // Users would see this warning for most commands
+    // warnings.push([
+    //   "--location",
+    //   "Requests defaults to following redirects, curl doesn't",
+    // ]);
+  }
+  const hasMaxRedirects =
+    followRedirects &&
+    maxRedirects &&
+    maxRedirects !== "0" &&
+    maxRedirects !== "30"; // Requests default
+
+  // Things that vary per-url:
+  // method (because --upload-file can make it PUT)
+  // data= (because of --upload-file)
+  // --output file
+  // params= (because of the query string)
+  // auth= (because the URL can have an auth string)
+  const seenWarnings: Set<string> = new Set();
+  const requestLines = [];
+  let extraEmptyLine = false;
+  for (const [urlObjIndex, urlObj] of request.urls.entries()) {
+    const requestsMethods = [
+      "GET",
+      "HEAD",
+      "POST",
+      "PATCH",
+      "PUT",
+      "DELETE",
+      "OPTIONS", // undocumented
+    ];
+    let fn;
+    const args = [];
+    const methodAsString = urlObj.method.toString();
+    if (urlObj.method.isString() && requestsMethods.includes(methodAsString)) {
+      fn = methodAsString.toLowerCase();
+    } else {
+      fn = "request";
+      args.push(repr(urlObj.method, osVars, imports));
+
+      if (
+        urlObj.method.isString() &&
+        methodAsString !== methodAsString.toUpperCase()
+      ) {
+        warnings.push([
+          "method",
+          "Requests will uppercase the HTTP method: " +
+            JSON.stringify(methodAsString),
+        ]);
+      }
+    }
+
+    let urlParamsStr;
+    let url = urlObj.url;
+    if (request.urls.length === 1) {
+      if (paramsStr) {
+        url = urlObj.urlWithoutQueryArray;
+      } else {
+        url = urlObj.url;
+      }
+    } else {
+      if (paramsStr) {
+        url = urlObj.urlWithOriginalQuery;
+      } else {
+        if (urlObj.queryArray && urlObj.queryArray.length > 0) {
+          const urlQueryAsEntries = formatDataAsEntries(
+            urlObj.queryArray,
+            osVars,
+            imports,
+            "params",
+          );
+          if (urlQueryAsEntries !== null) {
+            let percentWarn;
+            [urlParamsStr, percentWarn] = urlQueryAsEntries;
+            url = urlObj.urlWithoutQueryArray;
+
+            if (percentWarn) {
+              warnings.push([
+                "percent-encoded-spaces-in-query",
+                // TODO: will they?
+                'query contains spaces encoded by curl as "%20" which will be sent as "+" instead: ' +
+                  JSON.stringify(percentWarn),
+              ]);
+            }
+          } else if (readsFile(urlObj.queryArray)) {
+            [urlParamsStr, shouldEncodeParams] = formatDataAsStr(
+              urlObj.queryArray,
+              imports,
+              osVars,
+              "params",
+            );
+            url = urlObj.urlWithoutQueryArray;
+          }
+        }
+        // url = urlObj.url
+      }
+    }
+    args.push(repr(url, osVars, imports));
+
+    if (paramsStr || urlParamsStr) {
+      args.push("params=params" + (shouldEncodeParams ? ".encode()" : ""));
+    }
+    if (cookieStr && !request.cookieJar) {
+      args.push("cookies=cookies");
+    }
+    if (headerDict) {
+      args.push("headers=headers");
+    }
+    if (urlObj.uploadFile) {
+      if (request.urls.length > 1) {
+        // If there's more than one URL we could have --data for all
+        // of them and --upload-file for just one of them and we can't
+        // overwrite the `data` variable in that case.
+        args.push("data=file_contents");
+      } else {
+        args.push("data=data");
+      }
+    } else if (filesString) {
+      args.push("files=files");
+    } else if (request.data && !request.data.isEmpty()) {
+      if (jsonDataString) {
+        args.push("json=json_data");
+      } else {
+        args.push("data=data" + (shouldEncode ? ".encode()" : ""));
+      }
+    }
+    if (proxyDict) {
+      args.push("proxies=proxies");
+    }
+    if (certStr) {
+      args.push("cert=cert");
+    }
+    const certOrPath = request.cacert || request.capath;
+    if (request.insecure) {
+      args.push("verify=False");
+    } else if (certOrPath) {
+      args.push("verify=" + repr(certOrPath, osVars, imports));
+    }
+    // TODO: does this header check apply to all auth methods?
+    if (urlObj.auth && !request.headers.has("Authorization")) {
+      const [user, password] = urlObj.auth;
+      let auth =
+        "(" +
+        repr(user, osVars, imports) +
+        ", " +
+        repr(password, osVars, imports) +
+        ")";
+      switch (request.authType) {
+        case "basic":
+          break;
+        case "digest":
+          thirdPartyImports.add("requests.auth.HTTPDigestAuth");
+          auth = "HTTPDigestAuth" + auth;
+          break;
+        case "ntlm":
+        case "ntlm-wb":
+          thirdPartyImports.add("requests_ntlm.HttpNtlmAuth");
+          auth = "HttpNtlmAuth" + auth;
+          // TODO: this could stop being true
+          uniqueWarn(seenWarnings, warnings, [
+            "ntlm",
+            "requests-ntlm is unmaintained",
+          ]);
+          break;
+        case "negotiate":
+          thirdPartyImports.add("requests_gssapi.HTTPSPNEGOAuth");
+          auth = "HTTPSPNEGOAuth(";
+          if (request.delegation) {
+            if (eq(request.delegation, "always")) {
+              auth += "delegate=True";
+            } else if (eq(request.delegation, "none")) {
+              auth += "delegate=False";
+            } else {
+              uniqueWarn(seenWarnings, warnings, [
+                "delegation",
+                "--delegation value not supported: " +
+                  JSON.stringify(request.delegation.toString()),
+              ]);
+            }
+          }
+          auth += ")";
+          // TODO: use requests-kerberos instead?
+          // https://star-history.com/#pythongssapi/requests-gssapi&requests/requests-kerberos
+          uniqueWarn(seenWarnings, warnings, [
+            "negotiate",
+            "requests-gssapi is a fork of requests-kerberos",
+          ]);
+          break;
+        case "aws-sigv4":
+          thirdPartyImports.add("aws_requests_auth.aws_auth.AWSRequestsAuth");
+          // TODO: move this "auth = " to separate line
+          // TODO: try this.
+          auth =
+            "AWSRequestsAuth(aws_access_key=" +
+            repr(user, osVars, imports) +
+            ", aws_secret_access_key=" +
+            repr(password, osVars, imports) +
+            // TODO: parse
+            ", aws_host=" +
+            repr(request.awsSigV4 || new Word(), osVars, imports) +
+            ", aws_region=" +
+            repr(request.awsSigV4 || new Word(), osVars, imports) +
+            ", aws_service=" +
+            repr(request.awsSigV4 || new Word(), osVars, imports) +
+            ")";
+          uniqueWarn(seenWarnings, warnings, [
+            "--aws-sigv4",
+            "--aws-sigv4 value isn't parsed: " +
+              JSON.stringify(
+                request.awsSigV4 ? request.awsSigV4.toString() : "",
+              ),
+          ]);
+          break;
+        case "bearer":
+          // Shouldn't happen because hasHeader(Authorization) should be true
+          // TODO: use requests-oauthlib
+          break;
+      }
+      args.push("auth=" + auth);
+    }
+    if (request.timeout || request.connectTimeout) {
+      let connectTimeout = null;
+      if (request.connectTimeout) {
+        connectTimeout = asFloat(request.connectTimeout, osVars, imports);
+      }
+      let timeout = null;
+      if (request.timeout) {
+        if (request.timeout.isString()) {
+          timeout = request.timeout.toString();
+        } else {
+          timeout =
+            "float(" +
+            repr(request.timeout, osVars, imports, false, true) +
+            ")";
+        }
+      }
+
+      if (timeout && connectTimeout && timeout !== connectTimeout) {
+        args.push("timeout=(" + connectTimeout + ", " + timeout + ")");
+      } else if (timeout) {
+        args.push("timeout=" + timeout);
+      } else if (connectTimeout) {
+        args.push("timeout=(" + connectTimeout + ", None)");
+      }
+
+      if (timeout) {
+        uniqueWarn(seenWarnings, warnings, [
+          "--max-time",
+          // https://requests.readthedocs.io/en/latest/user/advanced/#timeouts
+          "unlike --max-time, Requests doesn't have a timeout for the whole request, only for the connect and the read",
+        ]);
+      }
+    }
+
+    if (!followRedirects || maxRedirects === "0") {
+      args.push("allow_redirects=False");
+    } else if (maxRedirects) {
+      if (maxRedirects === "-1") {
+        imports.add("math");
+        maxRedirects = "math.inf";
+      }
+    }
+    if (followRedirects && request.followRedirectsTrusted) {
+      uniqueWarn(seenWarnings, warnings, [
+        "--location-trusted",
+        "Requests doesn't have an easy way to disable removing the Authorization: header on redirect",
+      ]);
+    }
+
+    let requestLine = "";
+    const isSession = hasMaxRedirects || request.cookieJar;
+    const indentLevel = isSession ? 1 : 0;
+
+    if (isSession && urlObjIndex === 0) {
+      requestLine += "with requests.Session() as session:\n";
+      if (hasMaxRedirects) {
+        requestLine += `    session.max_redirects = ${maxRedirects}\n`;
+      }
+      if (request.cookieJar) {
+        requestLine += `    session.cookies = cookies\n`;
+      }
+    }
+
+    if (request.urls.length > 1) {
+      if (urlParamsStr) {
+        requestLine += indent(urlParamsStr, indentLevel);
+      }
+
+      if (urlObj.uploadFile) {
+        let uploadFileLine = "";
+        // TODO: https://docs.python-requests.org/en/latest/user/advanced/#streaming-uploads
+        if (eq(urlObj.uploadFile, "-") || eq(urlObj.uploadFile, ".")) {
+          uploadFileLine += "file_contents = sys.stdin.buffer.read()\n";
+          imports.add("sys");
+        } else {
+          uploadFileLine +=
+            "with open(" +
+            repr(urlObj.uploadFile, osVars, imports, false, true) +
+            ", 'rb') as f:\n";
+          uploadFileLine += "    file_contents = f.read()\n";
+        }
+        requestLine += indent(uploadFileLine, indentLevel);
+      }
+    }
+
+    const fnToCall =
+      "response = " + (isSession ? "session" : "requests") + "." + fn;
+    requestLine += indent(fnToCall + joinArgs(args) + "\n", indentLevel);
+
+    if (jsonDataString && dataString && !urlObj.uploadFile) {
+      // Adding empty lines to a "with" block breaks the code when pasted in the REPL
+      requestLine += isSession || request.urls.length > 1 ? "" : "\n";
+
+      // Should never be -1
+      args[args.indexOf("json=json_data")] = shouldEncode
+        ? "data=data.encode()"
+        : "data=data";
+      let dataAlternative =
+        "# Note: json_data will not be serialized by requests\n" +
+        "# exactly as it was in the original request.\n";
+      dataAlternative += commentOut(dataString);
+      dataAlternative += commentOut(fnToCall + joinArgs(args) + "\n");
+      requestLine += indent(dataAlternative, indentLevel);
+    }
+
+    if (urlObj.output && !eq(urlObj.output, "/dev/null")) {
+      let outputLine = "";
+      if (eq(request.urls[0].output, "-")) {
+        outputLine += "print(response.text)\n";
+      } else {
+        outputLine += isSession || request.urls.length > 1 ? "" : "\n";
+
+        outputLine +=
+          "with open(" +
+          repr(urlObj.output, osVars, imports, false, true) +
+          ", 'wb') as f:\n";
+        outputLine += "    f.write(response.content)\n";
+      }
+      requestLine += indent(outputLine, indentLevel);
+    }
+
+    if (
+      !isSession &&
+      // request.urls.length > 1 &&
+      (urlParamsStr ||
+        (dataString && jsonDataString) ||
+        urlObj.uploadFile ||
+        (urlObj.output && !eq(urlObj.output, "/dev/null")))
+    ) {
+      extraEmptyLine = true;
+    }
+    requestLines.push(requestLine);
+  }
+
+  pythonCode += requestLines.join(extraEmptyLine ? "\n" : "");
+
+  if (request.cookieJar) {
+    let cookieSaveLine = "cookies.save(";
+    if (!eq(request.cookieJar, cookieFile)) {
+      cookieSaveLine += repr(request.cookieJar, osVars, imports) + ", ";
+    }
+    cookieSaveLine += "ignore_discard=True, ignore_expires=True)\n"; // TODO: necessary?
+    pythonCode += indent(cookieSaveLine, 1);
+  }
+
+  if (request.http3) {
+    warnings.push([
+      "http3",
+      "this was an HTTP/3 request but requests only supports HTTP/1.1",
+    ]);
+  } else if (request.http2) {
+    warnings.push([
+      "http2",
+      "this was an HTTP/2 request but requests only supports HTTP/1.1",
+    ]);
+  } else if (request.headers.lowercase && request.headers.length > 1) {
+    warnings.push([
+      "--header",
+      "all the --header/-H names are lowercase, which means this may have been an HTTP/2 or HTTP/3 request. Requests only sends HTTP/1.1",
+    ]);
+  }
+
+  // It would be more correct to run the commands whenever we need
+  // their values instead of running them all at the beginning.
+  let variableCode = "";
+  if (Object.keys(osVars).length) {
+    for (const [varName, expr] of Object.entries(osVars)) {
+      variableCode += `${varName} = ${expr}\n`;
+    }
+    variableCode += "\n";
+  }
+
+  return variableCode + pythonCode;
+}
+
+export function printImports(imps: Set<string>): string {
+  let s = "";
+  for (const imp of Array.from(imps).sort()) {
+    if (imp === "read_headerfile") {
+      continue;
+    }
+    if (imp.includes(".")) {
+      const pos = imp.lastIndexOf(".");
+      const module = imp.slice(0, pos);
+      const name = imp.slice(pos + 1);
+      s += "from " + module + " import " + name + "\n";
+    } else {
+      s += "import " + imp + "\n";
+    }
+  }
+  return s;
+}
+
+export function _toPython(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const code = [];
+  let joinTwoLines = false;
+  const imports = new Set<string>();
+  const thirdPartyImports = new Set<string>();
+  for (const request of requests) {
+    const requestCode = requestToPython(
+      request,
+      warnings,
+      imports,
+      thirdPartyImports,
+    );
+    code.push(requestCode);
+
+    // If one of the requests defines variables (or its URL is very long),
+    // separate all the configs with two empty lines.
+    // curl example.com --next example.com
+    // vs.
+    // curl --data "foo=bar" example.com --next example.com
+    // (+1 for the trailing newline)
+    joinTwoLines ||= requestCode.split("\n").length > request.urls.length + 1;
+  }
+
+  let importCode = "";
+  importCode += printImports(imports);
+  if (imports.size > 1) {
+    importCode += "\n";
+  }
+  importCode += "import requests\n";
+  importCode += printImports(thirdPartyImports);
+  importCode += "\n";
+  if (imports.has("read_headerfile")) {
+    importCode += "def read_headerfile(filename):\n";
+    importCode += "    headers = {}\n";
+    importCode += "    with open(filename) as f:\n";
+    importCode += "        for line in f:\n";
+    importCode += "            line = line.split('#', 1)[0].strip()\n";
+    importCode += "            if line:\n";
+    importCode += "                [key, value] = line.split(':', 1)\n";
+    importCode += "                value = value or ''\n";
+    importCode += "                headers[key.strip()] = value.strip()\n";
+    importCode += "    return headers\n";
+    importCode += "\n";
+  }
+
+  return importCode + code.join(joinTwoLines ? "\n\n" : "\n");
+}
+
+export function toPythonWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const python = _toPython(requests, warnings);
+  return [python, warnings];
+}
+
+export function toPython(curlCommand: string | string[]): string {
+  return toPythonWarn(curlCommand)[0];
+}