@vercel/python-analysis 0.3.2 → 0.4.1

package/dist/index.cjs

@@ -52,6 +52,7 @@ __export(src_exports, {
   PythonBuild: () => PythonBuild,
   PythonConfigKind: () => PythonConfigKind,
   PythonImplementation: () => PythonImplementation,
+  PythonLockFileKind: () => PythonLockFileKind,
   PythonManifestConvertedKind: () => PythonManifestConvertedKind,
   PythonManifestKind: () => PythonManifestKind,
   PythonVariant: () => PythonVariant,
@@ -62,8 +63,10 @@ __export(src_exports, {
   UvConfigWorkspaceSchema: () => UvConfigWorkspaceSchema,
   UvIndexEntrySchema: () => UvIndexEntrySchema,
   containsAppOrHandler: () => containsAppOrHandler,
+  createMinimalManifest: () => createMinimalManifest,
   discoverPythonPackage: () => discoverPythonPackage,
-  selectPython: () => selectPython
+  selectPython: () => selectPython,
+  stringifyManifest: () => stringifyManifest
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -135,7 +138,14 @@ var isErrnoException = (error, code = void 0) => {
   return import_node_util.default.types.isNativeError(error) && "code" in error && (code === void 0 || error.code === code);
 };
 var PythonAnalysisError = class extends Error {
-  constructor({ message, code, path: path4, link, action }) {
+  constructor({
+    message,
+    code,
+    path: path4,
+    link,
+    action,
+    fileContent
+  }) {
     super(message);
     this.hideStackTrace = true;
     this.name = "PythonAnalysisError";
@@ -143,6 +153,7 @@ var PythonAnalysisError = class extends Error {
     this.path = path4;
     this.link = link;
     this.action = action;
+    this.fileContent = fileContent;
   }
 };
 
@@ -204,7 +215,8 @@ function parseRawConfig(content, filename, filetype = void 0) {
       throw new PythonAnalysisError({
         message: `Could not parse config file "${filename}": ${error.message}`,
         code: "PYTHON_CONFIG_PARSE_ERROR",
-        path: filename
+        path: filename,
+        fileContent: content
       });
     }
     throw error;
@@ -222,7 +234,8 @@ function parseConfig(content, filename, schema, filetype = void 0) {
       message: `Invalid config in "${filename}":
 ${issues}`,
       code: "PYTHON_CONFIG_VALIDATION_ERROR",
-      path: filename
+      path: filename,
+      fileContent: content
     });
   }
   return result.data;
@@ -501,6 +514,8 @@ function convertPipfileToPyprojectToml(pipfile) {
   }
   if (deps.length > 0) {
     pyproject.project = {
+      name: "app",
+      version: "0.1.0",
       dependencies: deps
     };
   }
@@ -558,6 +573,8 @@ function convertPipfileLockToPyprojectToml(pipfileLock) {
   }
   if (deps.length > 0) {
     pyproject.project = {
+      name: "app",
+      version: "0.1.0",
       dependencies: deps
     };
   }
@@ -634,7 +651,8 @@ var uvIndexEntrySchema = import_zod3.z.object({
   name: import_zod3.z.string(),
   url: import_zod3.z.string(),
   default: import_zod3.z.boolean().optional(),
-  explicit: import_zod3.z.boolean().optional()
+  explicit: import_zod3.z.boolean().optional(),
+  format: import_zod3.z.string().optional()
 });
 var uvConfigSchema = import_zod3.z.object({
   sources: import_zod3.z.record(import_zod3.z.union([dependencySourceSchema, import_zod3.z.array(dependencySourceSchema)])).optional(),
@@ -708,6 +726,7 @@ var import_node_path4 = require("path");
 var import_pip_requirements_js = require("pip-requirements-js");
 var PRIMARY_INDEX_NAME = "primary";
 var EXTRA_INDEX_PREFIX = "extra-";
+var FIND_LINKS_PREFIX = "find-links-";
 function parseGitUrl(url) {
   if (!url.startsWith("git+")) {
     return null;
@@ -749,6 +768,8 @@ function extractPipArguments(fileContent) {
   };
   const lines = fileContent.split(/\r?\n/);
   const cleanedLines = [];
+  const pathRequirements = [];
+  const editableRequirements = [];
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     const trimmed = line.trim();
@@ -763,11 +784,21 @@ function extractPipArguments(fileContent) {
       fullLine = fullLine.slice(0, -1) + lines[i + linesConsumed].trim();
     }
     const extracted = tryExtractPipArgument(fullLine, options);
-    if (extracted) {
+    if (extracted === true) {
+      i += linesConsumed;
+    } else if (typeof extracted === "object" && extracted.editable) {
+      editableRequirements.push(extracted.editable);
       i += linesConsumed;
     } else {
+      if (/^-[a-zA-Z]/.test(fullLine) && !fullLine.startsWith("-r") && !fullLine.startsWith("-c")) {
+        i += linesConsumed;
+        continue;
+      }
       const strippedLine = stripInlineHashes(fullLine);
-      if (strippedLine !== fullLine) {
+      const effectiveLine = (strippedLine !== fullLine ? strippedLine : fullLine).trim();
+      if (isPathOrUrlRequirement(effectiveLine)) {
+        pathRequirements.push(effectiveLine);
+      } else if (strippedLine !== fullLine) {
         cleanedLines.push(strippedLine);
       } else {
         cleanedLines.push(line);
@@ -780,7 +811,9 @@ function extractPipArguments(fileContent) {
   }
   return {
     cleanedContent: cleanedLines.join("\n"),
-    options
+    options,
+    pathRequirements,
+    editableRequirements
   };
 }
 function tryExtractPipArgument(line, options) {
@@ -819,6 +852,46 @@ function tryExtractPipArgument(line, options) {
       return true;
     }
   }
+  if (line.startsWith("--editable")) {
+    const path4 = extractArgValue(line, "--editable");
+    if (path4) {
+      return { editable: path4 };
+    }
+  }
+  if (line.startsWith("-e ") || line.startsWith("-e	")) {
+    const path4 = line.slice(2).trim();
+    if (path4) {
+      return { editable: path4 };
+    }
+  }
+  if (line.startsWith("--find-links")) {
+    const url = extractArgValue(line, "--find-links");
+    if (url) {
+      if (!options.findLinks)
+        options.findLinks = [];
+      options.findLinks.push(url);
+      return true;
+    }
+  }
+  if (line.startsWith("-f ") || line.startsWith("-f	")) {
+    const match = line.match(/^-f\s+(\S+)/);
+    if (match) {
+      if (!options.findLinks)
+        options.findLinks = [];
+      options.findLinks.push(match[1]);
+      return true;
+    }
+  }
+  if (line === "--no-index" || line.startsWith("--no-index ")) {
+    options.noIndex = true;
+    return true;
+  }
+  if (line.startsWith("--no-binary") || line.startsWith("--only-binary")) {
+    return true;
+  }
+  if (line.startsWith("--")) {
+    return true;
+  }
   return false;
 }
 function stripInlineHashes(line) {
@@ -834,15 +907,158 @@ function extractInlineHashes(line) {
   return hashes;
 }
 function extractArgValue(line, option) {
+  let value = null;
   if (line.startsWith(`${option}=`)) {
-    const value = line.slice(option.length + 1).trim();
-    return value || null;
+    value = line.slice(option.length + 1).trim();
+  } else if (line.startsWith(`${option} `) || line.startsWith(`${option}	`)) {
+    value = line.slice(option.length).trim();
   }
-  if (line.startsWith(`${option} `) || line.startsWith(`${option}	`)) {
-    const value = line.slice(option.length).trim();
-    return value || null;
+  if (!value)
+    return null;
+  const commentIdx = value.indexOf(" #");
+  if (commentIdx !== -1) {
+    value = value.slice(0, commentIdx).trim();
   }
-  return null;
+  return value || null;
+}
+function isPathOrUrlRequirement(line) {
+  if (line.startsWith("./") || line.startsWith("../"))
+    return true;
+  if (line.startsWith("/"))
+    return true;
+  if (line.startsWith("~/"))
+    return true;
+  if (/^(https?|ftp|file):\/\//i.test(line))
+    return true;
+  if (isBareArchiveFilename(line))
+    return true;
+  return false;
+}
+function isBareArchiveFilename(line) {
+  if (line.includes(" @ "))
+    return false;
+  let check = line;
+  const commentIdx = check.indexOf(" #");
+  if (commentIdx !== -1)
+    check = check.slice(0, commentIdx);
+  const markerIdx = check.indexOf(" ;");
+  if (markerIdx !== -1)
+    check = check.slice(0, markerIdx);
+  const extrasIdx = check.indexOf("[");
+  if (extrasIdx !== -1)
+    check = check.slice(0, extrasIdx);
+  check = check.trim();
+  return /\.(whl|tar\.gz|tar\.bz2|tar\.xz|zip)$/i.test(check);
+}
+function parseWheelFilename(filename) {
+  if (!filename.endsWith(".whl"))
+    return null;
+  const stem = filename.slice(0, -4);
+  const parts = stem.split("-");
+  if (parts.length < 5 || parts.length > 6)
+    return null;
+  const name = parts[0];
+  const version = parts[1];
+  if (!name || !version)
+    return null;
+  return {
+    name: name.replace(/_/g, "-"),
+    version
+  };
+}
+function parseSdistFilename(filename) {
+  let stem = filename;
+  for (const ext of [".tar.gz", ".tar.bz2", ".tar.xz", ".zip"]) {
+    if (stem.endsWith(ext)) {
+      stem = stem.slice(0, -ext.length);
+      break;
+    }
+  }
+  if (stem === filename)
+    return null;
+  const parts = stem.split("-");
+  let versionIdx = -1;
+  for (let i = 1; i < parts.length; i++) {
+    if (/^\d/.test(parts[i])) {
+      versionIdx = i;
+      break;
+    }
+  }
+  if (versionIdx === -1)
+    return null;
+  return {
+    name: parts.slice(0, versionIdx).join("-"),
+    version: parts.slice(versionIdx).join("-")
+  };
+}
+function normalizePathRequirement(rawLine) {
+  let line = rawLine;
+  const commentIdx = line.indexOf(" #");
+  if (commentIdx !== -1) {
+    line = line.slice(0, commentIdx).trim();
+  }
+  let markers;
+  const markerIdx = line.indexOf(" ;");
+  if (markerIdx !== -1) {
+    markers = line.slice(markerIdx + 2).trim();
+    line = line.slice(0, markerIdx).trim();
+  }
+  let extras;
+  const extrasMatch = line.match(/\[([^\]]+)\]$/);
+  if (extrasMatch) {
+    extras = extrasMatch[1].split(",").map((e) => e.trim());
+    line = line.slice(0, extrasMatch.index).trim();
+  }
+  const isUrl = /^(https?|ftp|file):\/\//i.test(line);
+  let filename;
+  if (isUrl) {
+    try {
+      const url = new URL(line);
+      filename = url.pathname.split("/").pop() || "";
+    } catch {
+      return null;
+    }
+  } else {
+    const cleanPath = line.replace(/\/+$/, "");
+    filename = cleanPath.split("/").pop() || "";
+  }
+  if (!filename)
+    return null;
+  let name;
+  let version;
+  const wheelParsed = parseWheelFilename(filename);
+  if (wheelParsed) {
+    name = wheelParsed.name;
+    version = wheelParsed.version;
+  }
+  if (!name) {
+    const sdistParsed = parseSdistFilename(filename);
+    if (sdistParsed) {
+      name = sdistParsed.name;
+      version = sdistParsed.version;
+    }
+  }
+  if (!name) {
+    name = filename.replace(/[-_.]+/g, "-").toLowerCase();
+  }
+  if (!name)
+    return null;
+  const req = { name };
+  if (version) {
+    req.version = `==${version}`;
+  }
+  if (extras && extras.length > 0) {
+    req.extras = extras;
+  }
+  if (markers) {
+    req.markers = markers;
+  }
+  if (isUrl) {
+    req.url = line;
+  } else {
+    req.source = { path: line };
+  }
+  return req;
 }
 function convertRequirementsToPyprojectToml(fileContent, readFile3) {
   const pyproject = {};
@@ -861,6 +1077,8 @@ function convertRequirementsToPyprojectToml(fileContent, readFile3) {
   }
   if (deps.length > 0) {
     pyproject.project = {
+      name: "app",
+      version: "0.1.0",
       dependencies: deps
     };
   }
@@ -892,6 +1110,15 @@ function buildIndexEntries(pipOptions) {
       url: pipOptions.extraIndexUrls[i]
     });
   }
+  if (pipOptions.findLinks) {
+    for (let i = 0; i < pipOptions.findLinks.length; i++) {
+      indexes.push({
+        name: `${FIND_LINKS_PREFIX}${i + 1}`,
+        url: pipOptions.findLinks[i],
+        format: "flat"
+      });
+    }
+  }
   return indexes;
 }
 function parseRequirementsFile(fileContent, readFile3) {
@@ -899,7 +1126,7 @@ function parseRequirementsFile(fileContent, readFile3) {
   return parseRequirementsFileInternal(fileContent, readFile3, visited);
 }
 function parseRequirementsFileInternal(fileContent, readFile3, visited) {
-  const { cleanedContent, options } = extractPipArguments(fileContent);
+  const { cleanedContent, options, pathRequirements, editableRequirements } = extractPipArguments(fileContent);
   const hashMap = buildHashMap(fileContent);
   const requirements = (0, import_pip_requirements_js.parsePipRequirementsFile)(cleanedContent);
   const normalized = [];
@@ -907,7 +1134,9 @@ function parseRequirementsFileInternal(fileContent, readFile3, visited) {
     requirementFiles: [...options.requirementFiles],
     constraintFiles: [...options.constraintFiles],
     indexUrl: options.indexUrl,
-    extraIndexUrls: [...options.extraIndexUrls]
+    extraIndexUrls: [...options.extraIndexUrls],
+    findLinks: options.findLinks ? [...options.findLinks] : void 0,
+    noIndex: options.noIndex
   };
   for (const req of requirements) {
     if (req.type === "RequirementsFile") {
@@ -927,6 +1156,23 @@ function parseRequirementsFileInternal(fileContent, readFile3, visited) {
       normalized.push(norm);
     }
   }
+  for (const rawPath of pathRequirements) {
+    const norm = normalizePathRequirement(rawPath);
+    if (norm != null) {
+      normalized.push(norm);
+    }
+  }
+  for (const rawPath of editableRequirements) {
+    const norm = normalizePathRequirement(rawPath);
+    if (norm != null) {
+      if (norm.source) {
+        norm.source.editable = true;
+      } else {
+        norm.source = { path: rawPath, editable: true };
+      }
+      normalized.push(norm);
+    }
+  }
   if (readFile3) {
     for (const refPath of mergedOptions.requirementFiles) {
       const refPathKey = (0, import_node_path4.normalize)(refPath);
@@ -963,6 +1209,18 @@ function parseRequirementsFileInternal(fileContent, readFile3, visited) {
             mergedOptions.constraintFiles.push(constraintPath);
           }
         }
+        if (refParsed.pipOptions.findLinks) {
+          if (!mergedOptions.findLinks)
+            mergedOptions.findLinks = [];
+          for (const fl of refParsed.pipOptions.findLinks) {
+            if (!mergedOptions.findLinks.includes(fl)) {
+              mergedOptions.findLinks.push(fl);
+            }
+          }
+        }
+        if (refParsed.pipOptions.noIndex) {
+          mergedOptions.noIndex = true;
+        }
       }
     }
   }
@@ -1451,6 +1709,11 @@ var PythonManifestKind = /* @__PURE__ */ ((PythonManifestKind2) => {
   PythonManifestKind2["PyProjectToml"] = "pyproject.toml";
   return PythonManifestKind2;
 })(PythonManifestKind || {});
+var PythonLockFileKind = /* @__PURE__ */ ((PythonLockFileKind2) => {
+  PythonLockFileKind2["UvLock"] = "uv.lock";
+  PythonLockFileKind2["PylockToml"] = "pylock.toml";
+  return PythonLockFileKind2;
+})(PythonLockFileKind || {});
 var PythonManifestConvertedKind = /* @__PURE__ */ ((PythonManifestConvertedKind2) => {
   PythonManifestConvertedKind2["Pipfile"] = "Pipfile";
   PythonManifestConvertedKind2["PipfileLock"] = "Pipfile.lock";
@@ -1492,6 +1755,7 @@ async function discoverPythonPackage({
   }
   let entrypointManifest;
   let workspaceManifest;
+  let workspaceLockFile;
   if (manifests.length === 0) {
     return {
       configs
@@ -1503,6 +1767,7 @@ async function discoverPythonPackage({
       manifests
     );
     workspaceManifest = entrypointWorkspaceManifest;
+    workspaceLockFile = entrypointWorkspaceManifest.lockFile;
     configs = configs.filter(
       (config) => Object.values(config).some(
         (cfg) => cfg !== void 0 && isSubpath(
@@ -1520,6 +1785,7 @@ async function discoverPythonPackage({
   return {
     manifest: entrypointManifest,
     workspaceManifest,
+    workspaceLockFile,
     configs,
     requiresPython
   };
@@ -1634,6 +1900,21 @@ async function loadPythonManifest(root, prefix) {
   }
   return manifest;
 }
+async function maybeLoadLockFile(root, subdir) {
+  const uvLockRelPath = import_node_path5.default.join(subdir, "uv.lock");
+  const uvLockPath = import_node_path5.default.join(root, uvLockRelPath);
+  const uvLockContent = await readFileTextIfExists(uvLockPath);
+  if (uvLockContent != null) {
+    return { path: uvLockRelPath, kind: "uv.lock" /* UvLock */ };
+  }
+  const pylockRelPath = import_node_path5.default.join(subdir, "pylock.toml");
+  const pylockPath = import_node_path5.default.join(root, pylockRelPath);
+  const pylockContent = await readFileTextIfExists(pylockPath);
+  if (pylockContent != null) {
+    return { path: pylockRelPath, kind: "pylock.toml" /* PylockToml */ };
+  }
+  return void 0;
+}
 async function maybeLoadPyProjectToml(root, subdir) {
   const pyprojectTomlRelPath = import_node_path5.default.join(subdir, "pyproject.toml");
   const pyprojectTomlPath = import_node_path5.default.join(root, pyprojectTomlRelPath);
@@ -1680,9 +1961,11 @@ async function maybeLoadPyProjectToml(root, subdir) {
       pyproject.tool.uv = uvToml;
     }
   }
+  const lockFile = await maybeLoadLockFile(root, subdir);
   return {
     path: pyprojectTomlRelPath,
-    data: pyproject
+    data: pyproject,
+    lockFile
   };
 }
 async function maybeLoadPipfile(root, subdir) {
@@ -1769,12 +2052,16 @@ async function maybeLoadRequirementsTxt(root, subdir, fileName) {
   } catch (error) {
     if (error instanceof PythonAnalysisError) {
       error.path = requirementsTxtRelPath;
+      if (!error.fileContent) {
+        error.fileContent = requirementsContent;
+      }
       throw error;
     }
     throw new PythonAnalysisError({
       message: `could not parse ${fileName}: ${error instanceof Error ? error.message : String(error)}`,
       code: "PYTHON_REQUIREMENTS_PARSE_ERROR",
-      path: requirementsTxtRelPath
+      path: requirementsTxtRelPath,
+      fileContent: requirementsContent
     });
   }
 }
@@ -1811,6 +2098,29 @@ async function maybeLoadPythonRequest(root, subdir) {
   };
 }
 
+// src/manifest/serialize.ts
+var import_smol_toml2 = __toESM(require("smol-toml"), 1);
+function stringifyManifest(data) {
+  return import_smol_toml2.default.stringify(data);
+}
+function createMinimalManifest(options = {}) {
+  const {
+    name = "app",
+    version = "0.1.0",
+    requiresPython,
+    dependencies = []
+  } = options;
+  return {
+    project: {
+      name,
+      version,
+      ...requiresPython && { "requires-python": requiresPython },
+      dependencies,
+      classifiers: ["Private :: Do Not Upload"]
+    }
+  };
+}
+
 // src/manifest/python-selector.ts
 function selectPython(constraints, available) {
   const warnings = [];
@@ -1984,6 +2294,7 @@ var HashDigestSchema = hashDigestSchema;
   PythonBuild,
   PythonConfigKind,
   PythonImplementation,
+  PythonLockFileKind,
   PythonManifestConvertedKind,
   PythonManifestKind,
   PythonVariant,
@@ -1994,6 +2305,8 @@ var HashDigestSchema = hashDigestSchema;
   UvConfigWorkspaceSchema,
   UvIndexEntrySchema,
   containsAppOrHandler,
+  createMinimalManifest,
   discoverPythonPackage,
-  selectPython
+  selectPython,
+  stringifyManifest
 });

package/dist/index.d.ts

@@ -7,8 +7,9 @@
  * @module @vercel/python-analysis
  */
 export { containsAppOrHandler } from './semantic/entrypoints';
-export type { PythonConfig, PythonConfigs, PythonManifest, PythonManifestOrigin, PythonPackage, PythonVersionConfig, } from './manifest/package';
-export { discoverPythonPackage, PythonConfigKind, PythonManifestConvertedKind, PythonManifestKind, } from './manifest/package';
+export type { PythonConfig, PythonConfigs, PythonLockFile, PythonManifest, PythonManifestOrigin, PythonPackage, PythonVersionConfig, } from './manifest/package';
+export { discoverPythonPackage, PythonConfigKind, PythonLockFileKind, PythonManifestConvertedKind, PythonManifestKind, } from './manifest/package';
+export { createMinimalManifest, stringifyManifest, type CreateMinimalManifestOptions, } from './manifest/serialize';
 export type { PythonSelectionResult } from './manifest/python-selector';
 export { selectPython } from './manifest/python-selector';
 export { PythonAnalysisError } from './util/error';