@vercel/python-analysis 0.4.1 → 0.5.0

package/dist/index.cjs

@@ -62,15 +62,21 @@ __export(src_exports, {
   UvConfigSchema: () => UvConfigSchema,
   UvConfigWorkspaceSchema: () => UvConfigWorkspaceSchema,
   UvIndexEntrySchema: () => UvIndexEntrySchema,
+  classifyPackages: () => classifyPackages,
   containsAppOrHandler: () => containsAppOrHandler,
   createMinimalManifest: () => createMinimalManifest,
   discoverPythonPackage: () => discoverPythonPackage,
+  generateRuntimeRequirements: () => generateRuntimeRequirements,
+  isPrivatePackageSource: () => isPrivatePackageSource,
+  normalizePackageName: () => normalizePackageName,
+  parseUvLock: () => parseUvLock,
+  scanDistributions: () => scanDistributions,
   selectPython: () => selectPython,
   stringifyManifest: () => stringifyManifest
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/semantic/load.ts
+// src/wasm/load.ts
 var import_promises = require("fs/promises");
 var import_node_module = require("module");
 var import_node_path = require("path");
@@ -89,7 +95,7 @@ function getWasmDir() {
 }
 async function getCoreModule(path4) {
   const wasmPath = (0, import_node_path.join)(getWasmDir(), path4);
-  const wasmBytes = await (0, import_promises.readFile)(wasmPath);
+  const wasmBytes = new Uint8Array(await (0, import_promises.readFile)(wasmPath));
   return WebAssembly.compile(wasmBytes);
 }
 async function importWasmModule() {
@@ -119,17 +125,107 @@ async function containsAppOrHandler(source) {
   return mod.containsAppOrHandler(source);
 }
 
+// src/manifest/dist-metadata.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+async function readDistInfoFile(distInfoDir, filename) {
+  try {
+    return await (0, import_promises2.readFile)((0, import_node_path2.join)(distInfoDir, filename), "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+async function scanDistributions(sitePackagesDir) {
+  const mod = await importWasmModule();
+  const index = /* @__PURE__ */ new Map();
+  let entries;
+  try {
+    entries = await (0, import_promises2.readdir)(sitePackagesDir);
+  } catch {
+    return index;
+  }
+  const distInfoDirs = entries.filter((e) => e.endsWith(".dist-info"));
+  for (const dirName of distInfoDirs) {
+    const distInfoPath = (0, import_node_path2.join)(sitePackagesDir, dirName);
+    const metadataContent = await readDistInfoFile(distInfoPath, "METADATA");
+    if (!metadataContent) {
+      console.debug(`Missing METADATA in ${dirName}`);
+      continue;
+    }
+    let metadata;
+    try {
+      metadata = mod.parseDistMetadata(
+        new TextEncoder().encode(metadataContent)
+      );
+    } catch (e) {
+      console.debug(`Failed to parse METADATA for ${dirName}: ${e}`);
+      continue;
+    }
+    const normalizedName = mod.normalizePackageName(metadata.name);
+    let files = [];
+    const recordContent = await readDistInfoFile(distInfoPath, "RECORD");
+    if (recordContent) {
+      try {
+        files = mod.parseRecord(recordContent);
+      } catch (e) {
+        console.warn(`Failed to parse RECORD for ${dirName}: ${e}`);
+      }
+    }
+    let origin;
+    const directUrlContent = await readDistInfoFile(
+      distInfoPath,
+      "direct_url.json"
+    );
+    if (directUrlContent) {
+      try {
+        origin = mod.parseDirectUrl(directUrlContent);
+      } catch (e) {
+        console.debug(`Failed to parse direct_url.json for ${dirName}: ${e}`);
+      }
+    }
+    const installerContent = await readDistInfoFile(distInfoPath, "INSTALLER");
+    const installer = installerContent?.trim() || void 0;
+    const dist = {
+      name: normalizedName,
+      version: metadata.version,
+      metadataVersion: metadata.metadataVersion,
+      summary: metadata.summary,
+      description: metadata.description,
+      descriptionContentType: metadata.descriptionContentType,
+      requiresDist: metadata.requiresDist,
+      requiresPython: metadata.requiresPython,
+      providesExtra: metadata.providesExtra,
+      author: metadata.author,
+      authorEmail: metadata.authorEmail,
+      maintainer: metadata.maintainer,
+      maintainerEmail: metadata.maintainerEmail,
+      license: metadata.license,
+      licenseExpression: metadata.licenseExpression,
+      classifiers: metadata.classifiers,
+      homePage: metadata.homePage,
+      projectUrls: metadata.projectUrls,
+      platforms: metadata.platforms,
+      dynamic: metadata.dynamic,
+      files,
+      origin,
+      installer
+    };
+    index.set(normalizedName, dist);
+  }
+  return index;
+}
+
 // src/manifest/package.ts
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var import_minimatch = require("minimatch");
 
 // src/util/config.ts
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var import_js_yaml = __toESM(require("js-yaml"), 1);
 var import_smol_toml = __toESM(require("smol-toml"), 1);
 
 // src/util/fs.ts
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 var import_fs_extra = require("fs-extra");
 
 // src/util/error.ts
@@ -177,21 +273,21 @@ async function readFileTextIfExists(file, encoding = "utf8") {
   }
 }
 function normalizePath(p) {
-  let np = import_node_path2.default.normalize(p);
-  if (np.endsWith(import_node_path2.default.sep)) {
+  let np = import_node_path3.default.normalize(p);
+  if (np.endsWith(import_node_path3.default.sep)) {
     np = np.slice(0, -1);
   }
   return np;
 }
 function isSubpath(somePath, parentPath) {
-  const rel = import_node_path2.default.relative(parentPath, somePath);
-  return rel === "" || !rel.startsWith("..") && !import_node_path2.default.isAbsolute(rel);
+  const rel = import_node_path3.default.relative(parentPath, somePath);
+  return rel === "" || !rel.startsWith("..") && !import_node_path3.default.isAbsolute(rel);
 }
 
 // src/util/config.ts
 function parseRawConfig(content, filename, filetype = void 0) {
   if (filetype === void 0) {
-    filetype = import_node_path3.default.extname(filename.toLowerCase());
+    filetype = import_node_path4.default.extname(filename.toLowerCase());
   }
   try {
     if (filetype === ".json") {
@@ -722,7 +818,7 @@ var PyProjectToolSectionSchema = pyProjectToolSectionSchema.passthrough();
 var PyProjectTomlSchema = pyProjectTomlSchema.passthrough();
 
 // src/manifest/requirements-txt-parser.ts
-var import_node_path4 = require("path");
+var import_node_path5 = require("path");
 var import_pip_requirements_js = require("pip-requirements-js");
 var PRIMARY_INDEX_NAME = "primary";
 var EXTRA_INDEX_PREFIX = "extra-";
@@ -1060,9 +1156,9 @@ function normalizePathRequirement(rawLine) {
   }
   return req;
 }
-function convertRequirementsToPyprojectToml(fileContent, readFile3) {
+function convertRequirementsToPyprojectToml(fileContent, readFile4) {
   const pyproject = {};
-  const parsed = parseRequirementsFile(fileContent, readFile3);
+  const parsed = parseRequirementsFile(fileContent, readFile4);
   const deps = [];
   const sources = {};
   for (const req of parsed.requirements) {
@@ -1121,11 +1217,11 @@ function buildIndexEntries(pipOptions) {
   }
   return indexes;
 }
-function parseRequirementsFile(fileContent, readFile3) {
+function parseRequirementsFile(fileContent, readFile4) {
   const visited = /* @__PURE__ */ new Set();
-  return parseRequirementsFileInternal(fileContent, readFile3, visited);
+  return parseRequirementsFileInternal(fileContent, readFile4, visited);
 }
-function parseRequirementsFileInternal(fileContent, readFile3, visited) {
+function parseRequirementsFileInternal(fileContent, readFile4, visited) {
   const { cleanedContent, options, pathRequirements, editableRequirements } = extractPipArguments(fileContent);
   const hashMap = buildHashMap(fileContent);
   const requirements = (0, import_pip_requirements_js.parsePipRequirementsFile)(cleanedContent);
@@ -1173,18 +1269,18 @@ function parseRequirementsFileInternal(fileContent, readFile3, visited) {
       normalized.push(norm);
     }
   }
-  if (readFile3) {
+  if (readFile4) {
     for (const refPath of mergedOptions.requirementFiles) {
-      const refPathKey = (0, import_node_path4.normalize)(refPath);
+      const refPathKey = (0, import_node_path5.normalize)(refPath);
       if (visited.has(refPathKey)) {
         continue;
       }
       visited.add(refPathKey);
-      const refContent = readFile3(refPath);
+      const refContent = readFile4(refPath);
       if (refContent != null) {
         const refParsed = parseRequirementsFileInternal(
           refContent,
-          readFile3,
+          readFile4,
           visited
         );
         const existingNames = new Set(
@@ -1727,7 +1823,7 @@ async function discoverPythonPackage({
 }) {
   const entrypointPath = normalizePath(entrypointDir);
   const rootPath = normalizePath(rootDir);
-  let prefix = import_node_path5.default.relative(rootPath, entrypointPath);
+  let prefix = import_node_path6.default.relative(rootPath, entrypointPath);
   if (prefix.startsWith("..")) {
     throw new PythonAnalysisError({
       message: "Entrypoint directory outside of repository root",
@@ -1751,7 +1847,7 @@ async function discoverPythonPackage({
     if (prefix === "" || prefix === ".") {
       break;
     }
-    prefix = import_node_path5.default.dirname(prefix);
+    prefix = import_node_path6.default.dirname(prefix);
   }
   let entrypointManifest;
   let workspaceManifest;
@@ -1771,8 +1867,8 @@ async function discoverPythonPackage({
     configs = configs.filter(
       (config) => Object.values(config).some(
         (cfg) => cfg !== void 0 && isSubpath(
-          import_node_path5.default.dirname(cfg.path),
-          import_node_path5.default.dirname(entrypointWorkspaceManifest.path)
+          import_node_path6.default.dirname(cfg.path),
+          import_node_path6.default.dirname(entrypointWorkspaceManifest.path)
         )
       )
     );
@@ -1845,9 +1941,9 @@ function findWorkspaceManifestFor(manifest, manifestStack) {
       if (!Array.isArray(exclude)) {
         exclude = [];
       }
-      const entrypointRelPath = import_node_path5.default.relative(
-        import_node_path5.default.dirname(parentManifest.path),
-        import_node_path5.default.dirname(manifest.path)
+      const entrypointRelPath = import_node_path6.default.relative(
+        import_node_path6.default.dirname(parentManifest.path),
+        import_node_path6.default.dirname(manifest.path)
       );
       if (members.length > 0 && members.some(
         (pat) => (0, import_minimatch.match)([entrypointRelPath], pat).length > 0
@@ -1882,7 +1978,7 @@ async function loadPythonManifest(root, prefix) {
           "requirements-frozen.txt",
           "requirements.txt",
           "requirements.in",
-          import_node_path5.default.join("requirements", "prod.txt")
+          import_node_path6.default.join("requirements", "prod.txt")
         ]) {
           const requirementsTxtManifest = await maybeLoadRequirementsTxt(
             root,
@@ -1901,14 +1997,14 @@ 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 uvLockRelPath = import_node_path6.default.join(subdir, "uv.lock");
+  const uvLockPath = import_node_path6.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 pylockRelPath = import_node_path6.default.join(subdir, "pylock.toml");
+  const pylockPath = import_node_path6.default.join(root, pylockRelPath);
   const pylockContent = await readFileTextIfExists(pylockPath);
   if (pylockContent != null) {
     return { path: pylockRelPath, kind: "pylock.toml" /* PylockToml */ };
@@ -1916,8 +2012,8 @@ async function maybeLoadLockFile(root, subdir) {
   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);
+  const pyprojectTomlRelPath = import_node_path6.default.join(subdir, "pyproject.toml");
+  const pyprojectTomlPath = import_node_path6.default.join(root, pyprojectTomlRelPath);
   let pyproject;
   try {
     pyproject = await readConfigIfExists(
@@ -1938,8 +2034,8 @@ async function maybeLoadPyProjectToml(root, subdir) {
   if (pyproject == null) {
     return null;
   }
-  const uvTomlRelPath = import_node_path5.default.join(subdir, "uv.toml");
-  const uvTomlPath = import_node_path5.default.join(root, uvTomlRelPath);
+  const uvTomlRelPath = import_node_path6.default.join(subdir, "uv.toml");
+  const uvTomlPath = import_node_path6.default.join(root, uvTomlRelPath);
   let uvToml;
   try {
     uvToml = await readConfigIfExists(uvTomlPath, UvConfigSchema);
@@ -1969,8 +2065,8 @@ async function maybeLoadPyProjectToml(root, subdir) {
   };
 }
 async function maybeLoadPipfile(root, subdir) {
-  const pipfileRelPath = import_node_path5.default.join(subdir, "Pipfile");
-  const pipfilePath = import_node_path5.default.join(root, pipfileRelPath);
+  const pipfileRelPath = import_node_path6.default.join(subdir, "Pipfile");
+  const pipfilePath = import_node_path6.default.join(root, pipfileRelPath);
   let pipfile;
   try {
     pipfile = await readConfigIfExists(pipfilePath, PipfileLikeSchema, ".toml");
@@ -1999,8 +2095,8 @@ async function maybeLoadPipfile(root, subdir) {
   };
 }
 async function maybeLoadPipfileLock(root, subdir) {
-  const pipfileLockRelPath = import_node_path5.default.join(subdir, "Pipfile.lock");
-  const pipfileLockPath = import_node_path5.default.join(root, pipfileLockRelPath);
+  const pipfileLockRelPath = import_node_path6.default.join(subdir, "Pipfile.lock");
+  const pipfileLockPath = import_node_path6.default.join(root, pipfileLockRelPath);
   let pipfileLock;
   try {
     pipfileLock = await readConfigIfExists(
@@ -2033,8 +2129,8 @@ async function maybeLoadPipfileLock(root, subdir) {
   };
 }
 async function maybeLoadRequirementsTxt(root, subdir, fileName) {
-  const requirementsTxtRelPath = import_node_path5.default.join(subdir, fileName);
-  const requirementsTxtPath = import_node_path5.default.join(root, requirementsTxtRelPath);
+  const requirementsTxtRelPath = import_node_path6.default.join(subdir, fileName);
+  const requirementsTxtPath = import_node_path6.default.join(root, requirementsTxtRelPath);
   const requirementsContent = await readFileTextIfExists(requirementsTxtPath);
   if (requirementsContent == null) {
     return null;
@@ -2074,8 +2170,8 @@ async function loadPythonConfigs(root, prefix) {
   return configs;
 }
 async function maybeLoadPythonRequest(root, subdir) {
-  const dotPythonVersionRelPath = import_node_path5.default.join(subdir, ".python-version");
-  const dotPythonVersionPath = import_node_path5.default.join(
+  const dotPythonVersionRelPath = import_node_path6.default.join(subdir, ".python-version");
+  const dotPythonVersionPath = import_node_path6.default.join(
     root,
     dotPythonVersionRelPath
   );
@@ -2121,6 +2217,95 @@ function createMinimalManifest(options = {}) {
   };
 }
 
+// src/manifest/uv-lock-parser.ts
+var import_smol_toml3 = __toESM(require("smol-toml"), 1);
+function parseUvLock(content, path4) {
+  let parsed;
+  try {
+    parsed = import_smol_toml3.default.parse(content);
+  } catch (error) {
+    throw new PythonAnalysisError({
+      message: `Could not parse uv.lock: ${error instanceof Error ? error.message : String(error)}`,
+      code: "PYTHON_UV_LOCK_PARSE_ERROR",
+      path: path4,
+      fileContent: content
+    });
+  }
+  const packages = (parsed.package ?? []).filter((pkg) => pkg.name && pkg.version).map((pkg) => ({
+    name: pkg.name,
+    version: pkg.version,
+    source: pkg.source
+  }));
+  return { version: parsed.version, packages };
+}
+var PUBLIC_PYPI_PATTERNS = [
+  "https://pypi.org",
+  "https://files.pythonhosted.org",
+  "pypi.org"
+];
+function isPublicPyPIRegistry(registryUrl) {
+  if (!registryUrl)
+    return true;
+  const normalized = registryUrl.toLowerCase();
+  return PUBLIC_PYPI_PATTERNS.some((pattern) => normalized.includes(pattern));
+}
+function isPrivatePackageSource(source) {
+  if (!source)
+    return false;
+  if (source.git)
+    return true;
+  if (source.path)
+    return true;
+  if (source.editable)
+    return true;
+  if (source.url)
+    return true;
+  if (source.virtual)
+    return true;
+  if (source.registry && !isPublicPyPIRegistry(source.registry)) {
+    return true;
+  }
+  return false;
+}
+function normalizePackageName(name) {
+  return name.toLowerCase().replace(/[-_.]+/g, "-");
+}
+function classifyPackages(options) {
+  const { lockFile, excludePackages = [] } = options;
+  const privatePackages = [];
+  const publicPackages = [];
+  const packageVersions = {};
+  const excludeSet = new Set(excludePackages.map(normalizePackageName));
+  for (const pkg of lockFile.packages) {
+    if (excludeSet.has(normalizePackageName(pkg.name))) {
+      continue;
+    }
+    packageVersions[pkg.name] = pkg.version;
+    if (isPrivatePackageSource(pkg.source)) {
+      privatePackages.push(pkg.name);
+    } else {
+      publicPackages.push(pkg.name);
+    }
+  }
+  return { privatePackages, publicPackages, packageVersions };
+}
+function generateRuntimeRequirements(classification) {
+  const lines = [
+    "# Auto-generated requirements for runtime installation",
+    "# Private packages are bundled separately and not listed here.",
+    ""
+  ];
+  for (const pkgName of classification.publicPackages) {
+    const version = classification.packageVersions[pkgName];
+    if (version) {
+      lines.push(`${pkgName}==${version}`);
+    } else {
+      lines.push(pkgName);
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/manifest/python-selector.ts
 function selectPython(constraints, available) {
   const warnings = [];
@@ -2304,9 +2489,15 @@ var HashDigestSchema = hashDigestSchema;
   UvConfigSchema,
   UvConfigWorkspaceSchema,
   UvIndexEntrySchema,
+  classifyPackages,
   containsAppOrHandler,
   createMinimalManifest,
   discoverPythonPackage,
+  generateRuntimeRequirements,
+  isPrivatePackageSource,
+  normalizePackageName,
+  parseUvLock,
+  scanDistributions,
   selectPython,
   stringifyManifest
 });

package/dist/index.d.ts

@@ -7,9 +7,13 @@
  * @module @vercel/python-analysis
  */
 export { containsAppOrHandler } from './semantic/entrypoints';
+export type { Distribution, DistributionIndex, PackagePath, DirectUrlInfo, } from './manifest/dist-metadata';
+export { scanDistributions } from './manifest/dist-metadata';
 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 { ClassifyPackagesOptions, PackageClassification, UvLockFile, UvLockPackage, UvLockPackageSource, } from './manifest/uv-lock-parser';
+export { classifyPackages, generateRuntimeRequirements, isPrivatePackageSource, normalizePackageName, parseUvLock, } from './manifest/uv-lock-parser';
 export type { PythonSelectionResult } from './manifest/python-selector';
 export { selectPython } from './manifest/python-selector';
 export { PythonAnalysisError } from './util/error';