@vercel/python-analysis 0.1.1

package/dist/manifest/python-specifiers.js

@@ -0,0 +1,156 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var python_specifiers_exports = {};
+__export(python_specifiers_exports, {
+  PythonBuild: () => PythonBuild,
+  PythonImplementation: () => PythonImplementation,
+  PythonVariant: () => PythonVariant,
+  PythonVersion: () => PythonVersion
+});
+module.exports = __toCommonJS(python_specifiers_exports);
+const PythonImplementation = {
+  knownLongNames() {
+    return {
+      python: "cpython",
+      cpython: "cpython",
+      pypy: "pypy",
+      pyodide: "pyodide",
+      graalpy: "graalpy"
+    };
+  },
+  knownShortNames() {
+    return { cp: "cpython", pp: "pypy", gp: "graalpy" };
+  },
+  knownNames() {
+    return { ...this.knownLongNames(), ...this.knownShortNames() };
+  },
+  parse(s) {
+    const impl = this.knownNames()[s];
+    if (impl !== void 0) {
+      return impl;
+    } else {
+      return { implementation: s };
+    }
+  },
+  isUnknown(impl) {
+    return impl.implementation !== void 0;
+  },
+  toString(impl) {
+    switch (impl) {
+      case "cpython":
+        return "cpython";
+      case "pypy":
+        return "pypy";
+      case "pyodide":
+        return "pyodide";
+      case "graalpy":
+        return "graalpy";
+      default:
+        return impl.implementation;
+    }
+  },
+  toStringPretty(impl) {
+    switch (impl) {
+      case "cpython":
+        return "CPython";
+      case "pypy":
+        return "PyPy";
+      case "pyodide":
+        return "PyOdide";
+      case "graalpy":
+        return "GraalPy";
+      default:
+        return impl.implementation;
+    }
+  }
+};
+const PythonVariant = {
+  parse(s) {
+    switch (s) {
+      case "default":
+        return "default";
+      case "d":
+      case "debug":
+        return "debug";
+      case "freethreaded":
+        return "freethreaded";
+      case "t":
+        return "freethreaded";
+      case "gil":
+        return "gil";
+      case "freethreaded+debug":
+        return "freethreaded+debug";
+      case "td":
+        return "freethreaded+debug";
+      case "gil+debug":
+        return "gil+debug";
+      default:
+        return { type: "unknown", variant: s };
+    }
+  },
+  toString(v) {
+    switch (v) {
+      case "default":
+        return "default";
+      case "debug":
+        return "debug";
+      case "freethreaded":
+        return "freethreaded";
+      case "gil":
+        return "gil";
+      case "freethreaded+debug":
+        return "freethreaded+debug";
+      case "gil+debug":
+        return "gil+debug";
+      default:
+        return v.variant;
+    }
+  }
+};
+const PythonVersion = {
+  toString(version) {
+    let verstr = `${version.major}.${version.minor}`;
+    if (version.patch !== void 0) {
+      verstr = `${verstr}.${version.patch}`;
+    }
+    if (version.prerelease !== void 0) {
+      verstr = `${verstr}${version.prerelease}`;
+    }
+    return verstr;
+  }
+};
+const PythonBuild = {
+  toString(build) {
+    const parts = [
+      PythonImplementation.toString(build.implementation),
+      `${PythonVersion.toString(build.version)}+${PythonVariant.toString(build.variant)}`,
+      build.os,
+      build.architecture,
+      build.libc
+    ];
+    return parts.join("-");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PythonBuild,
+  PythonImplementation,
+  PythonVariant,
+  PythonVersion
+});

package/dist/manifest/requirement/schema.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Zod schemas for Python dependency requirement types.
+ *
+ * Types are defined in types.ts (source of truth).
+ * Schemas are generated by ts-to-zod and re-exported here with proper typing.
+ *
+ * @module requirement/schema
+ */
+import type { z } from 'zod';
+import type { DependencySource, NormalizedRequirement } from './types';
+/**
+ * Schema for dependency source information (git, path, or index).
+ * Used in [tool.uv.sources] in pyproject.toml.
+ */
+export declare const DependencySourceSchema: z.ZodType<DependencySource, z.ZodTypeDef, DependencySource>;
+/**
+ * Schema for a normalized representation of a Python dependency.
+ * This is the common format used by all parsers before converting to PEP 508 format.
+ *
+ * Note: This schema uses the generated version without passthrough since
+ * NormalizedRequirement is an internal type with a known structure.
+ */
+export declare const NormalizedRequirementSchema: z.ZodType<NormalizedRequirement, z.ZodTypeDef, NormalizedRequirement>;
+/**
+ * Schema for parsed hash digest for a requirement.
+ * Format: algorithm:hash_value (e.g., "sha256:abc123...")
+ */
+export declare const HashDigestSchema: z.ZodType<string, z.ZodTypeDef, string>;

package/dist/manifest/requirement/schema.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_exports = {};
+__export(schema_exports, {
+  DependencySourceSchema: () => DependencySourceSchema,
+  HashDigestSchema: () => HashDigestSchema,
+  NormalizedRequirementSchema: () => NormalizedRequirementSchema
+});
+module.exports = __toCommonJS(schema_exports);
+var import_schema = require("./schema.zod");
+const DependencySourceSchema = import_schema.dependencySourceSchema.passthrough();
+const NormalizedRequirementSchema = import_schema.normalizedRequirementSchema;
+const HashDigestSchema = import_schema.hashDigestSchema;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DependencySourceSchema,
+  HashDigestSchema,
+  NormalizedRequirementSchema
+});

package/dist/manifest/requirement/schema.zod.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+export declare const dependencySourceSchema: z.ZodObject<{
+    index: z.ZodOptional<z.ZodString>;
+    git: z.ZodOptional<z.ZodString>;
+    rev: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    editable: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    index?: string | undefined;
+    git?: string | undefined;
+    rev?: string | undefined;
+    path?: string | undefined;
+    editable?: boolean | undefined;
+}, {
+    index?: string | undefined;
+    git?: string | undefined;
+    rev?: string | undefined;
+    path?: string | undefined;
+    editable?: boolean | undefined;
+}>;
+export declare const normalizedRequirementSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    extras: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    markers: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    hashes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    source: z.ZodOptional<z.ZodObject<{
+        index: z.ZodOptional<z.ZodString>;
+        git: z.ZodOptional<z.ZodString>;
+        rev: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        editable: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        index?: string | undefined;
+        git?: string | undefined;
+        rev?: string | undefined;
+        path?: string | undefined;
+        editable?: boolean | undefined;
+    }, {
+        index?: string | undefined;
+        git?: string | undefined;
+        rev?: string | undefined;
+        path?: string | undefined;
+        editable?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version?: string | undefined;
+    extras?: string[] | undefined;
+    markers?: string | undefined;
+    url?: string | undefined;
+    hashes?: string[] | undefined;
+    source?: {
+        index?: string | undefined;
+        git?: string | undefined;
+        rev?: string | undefined;
+        path?: string | undefined;
+        editable?: boolean | undefined;
+    } | undefined;
+}, {
+    name: string;
+    version?: string | undefined;
+    extras?: string[] | undefined;
+    markers?: string | undefined;
+    url?: string | undefined;
+    hashes?: string[] | undefined;
+    source?: {
+        index?: string | undefined;
+        git?: string | undefined;
+        rev?: string | undefined;
+        path?: string | undefined;
+        editable?: boolean | undefined;
+    } | undefined;
+}>;
+export declare const hashDigestSchema: z.ZodString;

package/dist/manifest/requirement/schema.zod.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_zod_exports = {};
+__export(schema_zod_exports, {
+  dependencySourceSchema: () => dependencySourceSchema,
+  hashDigestSchema: () => hashDigestSchema,
+  normalizedRequirementSchema: () => normalizedRequirementSchema
+});
+module.exports = __toCommonJS(schema_zod_exports);
+var import_zod = require("zod");
+const dependencySourceSchema = import_zod.z.object({
+  index: import_zod.z.string().optional(),
+  git: import_zod.z.string().optional(),
+  rev: import_zod.z.string().optional(),
+  path: import_zod.z.string().optional(),
+  editable: import_zod.z.boolean().optional()
+});
+const normalizedRequirementSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  version: import_zod.z.string().optional(),
+  extras: import_zod.z.array(import_zod.z.string()).optional(),
+  markers: import_zod.z.string().optional(),
+  url: import_zod.z.string().optional(),
+  hashes: import_zod.z.array(import_zod.z.string()).optional(),
+  source: dependencySourceSchema.optional()
+});
+const hashDigestSchema = import_zod.z.string();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dependencySourceSchema,
+  hashDigestSchema,
+  normalizedRequirementSchema
+});

package/dist/manifest/requirement/types.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Pure TypeScript interface definitions for Python dependency requirement types.
+ *
+ * These interfaces serve as the source of truth for types.
+ * Zod schemas are generated from these using ts-to-zod.
+ *
+ * @module requirement/types
+ */
+/**
+ * Dependency source information (git, path, or index).
+ * Used in [tool.uv.sources] in pyproject.toml.
+ * @passthrough
+ */
+export interface DependencySource {
+    /** Index name for the dependency (e.g., "private-pypi") */
+    index?: string;
+    /** Git repository URL */
+    git?: string;
+    /** Git revision (branch, tag, or commit hash) */
+    rev?: string;
+    /** Local path to the dependency */
+    path?: string;
+    /** Whether the dependency is installed in editable mode */
+    editable?: boolean;
+}
+/**
+ * A normalized representation of a Python dependency.
+ * This is the common format used by all parsers before converting to PEP 508 format.
+ */
+export interface NormalizedRequirement {
+    /** Package name (e.g., "requests") */
+    name: string;
+    /** Version specifier (e.g., ">=1.0,<2.0") */
+    version?: string;
+    /** Extra features (e.g., ["security", "socks"]) */
+    extras?: string[];
+    /** Environment markers (e.g., "python_version >= '3.8'") */
+    markers?: string;
+    /** Direct URL for the package */
+    url?: string;
+    /** Hash digests for verification (e.g., ["sha256:abc123..."]) */
+    hashes?: string[];
+    /** Source information for uv (git, path, or index) */
+    source?: DependencySource;
+}
+/**
+ * Parsed hash digest for a requirement.
+ * Format: algorithm:hash_value (e.g., "sha256:abc123...")
+ */
+export type HashDigest = string;

package/dist/manifest/requirement/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/manifest/requirements-txt-parser.d.ts

@@ -0,0 +1,55 @@
+import type { PyProjectToml } from './pyproject/types';
+import type { NormalizedRequirement } from './requirement/types';
+/**
+ * Parsed pip arguments from requirements file.
+ */
+export interface PipOptions {
+    /** Files referenced via -r or --requirement */
+    requirementFiles: string[];
+    /** Files referenced via -c or --constraint */
+    constraintFiles: string[];
+    /** Primary index URL (--index-url or -i) - only the last one is kept */
+    indexUrl?: string;
+    /** Extra index URLs (--extra-index-url) */
+    extraIndexUrls: string[];
+}
+/**
+ * Result of parsing a requirements file with pip options.
+ */
+export interface ParsedRequirementsFile {
+    requirements: NormalizedRequirement[];
+    pipOptions: PipOptions;
+}
+/**
+ * Function type for reading referenced requirement files.
+ */
+export type ReadFileFn = (path: string) => string | null;
+/**
+ * Convert a requirements.txt content to a pyproject.toml object suitable for uv.
+ *
+ * This creates a minimal pyproject:
+ *
+ * [project]
+ * dependencies = [...]
+ *
+ * [tool.uv.sources]
+ * package = { git = "..." }
+ *
+ * Note: Hash information is not included in pyproject.toml output.
+ *
+ * @param fileContent - The content of the requirements.txt file
+ * @param readFile - Optional function to read referenced requirement files (-r, --requirement).
+ *                   If provided, referenced files will be recursively processed.
+ */
+export declare function convertRequirementsToPyprojectToml(fileContent: string, readFile?: ReadFileFn): PyProjectToml;
+/**
+ * Parse requirements file content with full pip options support.
+ * Returns both the normalized requirements and the parsed pip options
+ * (--requirement, --constraint, --index-url, --extra-index-url, --hash).
+ *
+ * @param fileContent - The content of the requirements.txt file
+ * @param readFile - Optional function to read referenced requirement files (-r, --requirement).
+ *                   If provided, referenced files will be recursively processed and their
+ *                   requirements merged into the result.
+ */
+export declare function parseRequirementsFile(fileContent: string, readFile?: ReadFileFn): ParsedRequirementsFile;