@vercel/python-analysis 0.1.1

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

@@ -0,0 +1,94 @@
+"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, {
+  licenseObjectSchema: () => licenseObjectSchema,
+  licenseSchema: () => licenseSchema,
+  personSchema: () => personSchema,
+  pyProjectBuildSystemSchema: () => pyProjectBuildSystemSchema,
+  pyProjectDependencyGroupsSchema: () => pyProjectDependencyGroupsSchema,
+  pyProjectProjectSchema: () => pyProjectProjectSchema,
+  pyProjectTomlSchema: () => pyProjectTomlSchema,
+  pyProjectToolSectionSchema: () => pyProjectToolSectionSchema,
+  readmeObjectSchema: () => readmeObjectSchema,
+  readmeSchema: () => readmeSchema
+});
+module.exports = __toCommonJS(schema_zod_exports);
+var import_zod = require("zod");
+var import_schema = require("./../uv-config/schema.zod");
+const pyProjectBuildSystemSchema = import_zod.z.object({
+  requires: import_zod.z.array(import_zod.z.string()),
+  "build-backend": import_zod.z.string().optional(),
+  "backend-path": import_zod.z.array(import_zod.z.string()).optional()
+});
+const personSchema = import_zod.z.object({
+  name: import_zod.z.string().optional(),
+  email: import_zod.z.string().optional()
+});
+const readmeObjectSchema = import_zod.z.object({
+  file: import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]),
+  content_type: import_zod.z.string().optional()
+});
+const readmeSchema = import_zod.z.union([import_zod.z.string(), readmeObjectSchema]);
+const licenseObjectSchema = import_zod.z.object({
+  text: import_zod.z.string().optional(),
+  file: import_zod.z.string().optional()
+});
+const licenseSchema = import_zod.z.union([import_zod.z.string(), licenseObjectSchema]);
+const pyProjectProjectSchema = import_zod.z.object({
+  name: import_zod.z.string().optional(),
+  version: import_zod.z.string().optional(),
+  description: import_zod.z.string().optional(),
+  readme: readmeSchema.optional(),
+  keywords: import_zod.z.array(import_zod.z.string()).optional(),
+  authors: import_zod.z.array(personSchema).optional(),
+  maintainers: import_zod.z.array(personSchema).optional(),
+  license: licenseSchema.optional(),
+  classifiers: import_zod.z.array(import_zod.z.string()).optional(),
+  urls: import_zod.z.record(import_zod.z.string()).optional(),
+  dependencies: import_zod.z.array(import_zod.z.string()).optional(),
+  "optional-dependencies": import_zod.z.record(import_zod.z.array(import_zod.z.string())).optional(),
+  dynamic: import_zod.z.array(import_zod.z.string()).optional(),
+  "requires-python": import_zod.z.string().optional(),
+  scripts: import_zod.z.record(import_zod.z.string()).optional(),
+  entry_points: import_zod.z.record(import_zod.z.record(import_zod.z.string())).optional()
+});
+const pyProjectDependencyGroupsSchema = import_zod.z.record(import_zod.z.array(import_zod.z.string()));
+const pyProjectToolSectionSchema = import_zod.z.object({
+  uv: import_schema.uvConfigSchema.optional()
+});
+const pyProjectTomlSchema = import_zod.z.object({
+  project: pyProjectProjectSchema.optional(),
+  "build-system": pyProjectBuildSystemSchema.optional(),
+  "dependency-groups": pyProjectDependencyGroupsSchema.optional(),
+  tool: pyProjectToolSectionSchema.optional()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  licenseObjectSchema,
+  licenseSchema,
+  personSchema,
+  pyProjectBuildSystemSchema,
+  pyProjectDependencyGroupsSchema,
+  pyProjectProjectSchema,
+  pyProjectTomlSchema,
+  pyProjectToolSectionSchema,
+  readmeObjectSchema,
+  readmeSchema
+});

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

@@ -0,0 +1,93 @@
+/**
+ * Pure TypeScript interface definitions for pyproject.toml types.
+ *
+ * These interfaces serve as the source of truth for types.
+ * Zod schemas are generated from these using ts-to-zod.
+ *
+ * @module pyproject/types
+ */
+import type { UvConfig } from '../uv-config/types';
+/**
+ * [build-system] per PEP 518.
+ * @passthrough
+ */
+export interface PyProjectBuildSystem {
+    requires: string[];
+    'build-backend'?: string;
+    'backend-path'?: string[];
+}
+/**
+ * Author/maintainer entry.
+ * @passthrough
+ */
+export interface Person {
+    name?: string;
+    email?: string;
+}
+/**
+ * Readme field as an object.
+ * @passthrough
+ */
+export interface ReadmeObject {
+    file: string | string[];
+    content_type?: string;
+}
+/**
+ * Readme field (can be string or object).
+ */
+export type Readme = string | ReadmeObject;
+/**
+ * License field as an object.
+ * @passthrough
+ */
+export interface LicenseObject {
+    text?: string;
+    file?: string;
+}
+/**
+ * License field (can be string or object).
+ */
+export type License = string | LicenseObject;
+/**
+ * Core PEP 621 fields for [project].
+ * @passthrough
+ */
+export interface PyProjectProject {
+    name?: string;
+    version?: string;
+    description?: string;
+    readme?: Readme;
+    keywords?: string[];
+    authors?: Person[];
+    maintainers?: Person[];
+    license?: License;
+    classifiers?: string[];
+    urls?: Record<string, string>;
+    dependencies?: string[];
+    'optional-dependencies'?: Record<string, string[]>;
+    dynamic?: string[];
+    'requires-python'?: string;
+    scripts?: Record<string, string>;
+    entry_points?: Record<string, Record<string, string>>;
+}
+/**
+ * [dependency-groups].
+ */
+export type PyProjectDependencyGroups = Record<string, string[]>;
+/**
+ * [tool.FOO] section.
+ * @passthrough
+ */
+export interface PyProjectToolSection {
+    uv?: UvConfig;
+}
+/**
+ * A pyproject.toml file.
+ * @passthrough
+ */
+export interface PyProjectToml {
+    project?: PyProjectProject;
+    'build-system'?: PyProjectBuildSystem;
+    'dependency-groups'?: PyProjectDependencyGroups;
+    tool?: PyProjectToolSection;
+}

package/dist/manifest/pyproject/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/python-selector.d.ts

@@ -0,0 +1,123 @@
+import type { Pep440Constraint } from './pep440';
+import type { PythonBuild, PythonConstraint, PythonRequest, PythonVariant, PythonVersion } from './python-specifiers';
+import { PythonImplementation } from './python-specifiers';
+/**
+ * Result of selecting a Python build.
+ */
+export interface PythonSelectionResult {
+    /** The selected build, or null if no build matches. */
+    build: PythonBuild | null;
+    /** Error messages if selection failed. */
+    errors?: string[];
+    /** Warning messages (e.g., non-overlapping constraints). */
+    warnings?: string[];
+}
+/**
+ * Select the best Python build that matches all constraints.
+ *
+ * @param constraints - Array of Python constraints from various sources
+ * @param available - Array of available Python builds to choose from
+ * @returns The first matching build, or null with errors/warnings if none match
+ */
+export declare function selectPython(constraints: PythonConstraint[], available: PythonBuild[]): PythonSelectionResult;
+/**
+ * Convert a PythonVersion to a string suitable for PEP 440 comparison.
+ *
+ * @param version - The Python version object to convert
+ * @returns A version string like "3.12", "3.12.1", or "3.13.0a1"
+ *
+ * @example
+ * pythonVersionToString({ major: 3, minor: 12 }) // "3.12"
+ * pythonVersionToString({ major: 3, minor: 12, patch: 1 }) // "3.12.1"
+ * pythonVersionToString({ major: 3, minor: 13, patch: 0, prerelease: "a1" }) // "3.13.0a1"
+ */
+export declare function pythonVersionToString(version: PythonVersion): string;
+/**
+ * Convert an array of Pep440Constraint to a specifier string.
+ *
+ * @param constraints - Array of PEP 440 version constraints
+ * @returns A comma-separated specifier string like ">=3.12,<3.14"
+ *
+ * @example
+ * pep440ConstraintsToString([{ operator: '>=', version: '3.12', prefix: '' }]) // ">=3.12"
+ * pep440ConstraintsToString([
+ *   { operator: '>=', version: '3.12', prefix: '' },
+ *   { operator: '<', version: '3.14', prefix: '' }
+ * ]) // ">=3.12,<3.14"
+ */
+export declare function pep440ConstraintsToString(constraints: Pep440Constraint[]): string;
+/**
+ * Check if two PythonImplementation values are equal.
+ *
+ * Handles both known implementations (cpython, pypy, etc.) and unknown
+ * implementations (custom strings). Known implementations are compared
+ * by identity, unknown implementations by their string value.
+ *
+ * @param buildImpl - The implementation of the available build
+ * @param requestImpl - The implementation requested by the constraint
+ * @returns True if the implementations match
+ *
+ * @example
+ * implementationsMatch('cpython', 'cpython') // true
+ * implementationsMatch('cpython', 'pypy') // false
+ * implementationsMatch({ implementation: 'custom' }, { implementation: 'custom' }) // true
+ */
+export declare function implementationsMatch(buildImpl: PythonImplementation, requestImpl: PythonImplementation): boolean;
+/**
+ * Check if two PythonVariant values are equal.
+ *
+ * Handles both known variants (default, debug, freethreaded, etc.) and
+ * unknown variants. Known variants are compared by identity, unknown
+ * variants by their string value.
+ *
+ * @param buildVariant - The variant of the available build
+ * @param requestVariant - The variant requested by the constraint
+ * @returns True if the variants match
+ *
+ * @example
+ * variantsMatch('default', 'default') // true
+ * variantsMatch('freethreaded', 'debug') // false
+ * variantsMatch({ type: 'unknown', variant: 'custom' }, { type: 'unknown', variant: 'custom' }) // true
+ */
+export declare function variantsMatch(buildVariant: PythonVariant, requestVariant: PythonVariant): boolean;
+/**
+ * Check if a build matches a single PythonRequest.
+ *
+ * A build matches a request if all specified fields in the request match
+ * the corresponding fields in the build. Unspecified fields in the request
+ * are treated as wildcards (match anything).
+ *
+ * @param build - The available Python build to check
+ * @param request - The Python request specifying desired properties
+ * @returns True if the build satisfies all specified requirements in the request
+ *
+ * @example
+ * // Request with only version constraint
+ * buildMatchesRequest(build, { version: { constraint: [{ operator: '>=', version: '3.12', prefix: '' }] } })
+ *
+ * // Request with implementation and platform
+ * buildMatchesRequest(build, { implementation: 'cpython', platform: { os: 'linux' } })
+ */
+export declare function buildMatchesRequest(build: PythonBuild, request: PythonRequest): boolean;
+/**
+ * Check if a build matches a PythonConstraint.
+ *
+ * A constraint contains one or more requests combined with OR logic.
+ * The constraint is satisfied if the build matches at least one of its requests.
+ * An empty request array is treated as "match anything".
+ *
+ * @param build - The available Python build to check
+ * @param constraint - The constraint containing one or more requests
+ * @returns True if the build matches at least one request in the constraint
+ *
+ * @example
+ * // Constraint with multiple alternative requests (OR logic)
+ * buildMatchesConstraint(build, {
+ *   request: [
+ *     { implementation: 'cpython', version: { constraint: [...] } },
+ *     { implementation: 'pypy', version: { constraint: [...] } }
+ *   ],
+ *   source: '.python-version'
+ * })
+ */
+export declare function buildMatchesConstraint(build: PythonBuild, constraint: PythonConstraint): boolean;

package/dist/manifest/python-selector.js

@@ -0,0 +1,185 @@
+"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_selector_exports = {};
+__export(python_selector_exports, {
+  buildMatchesConstraint: () => buildMatchesConstraint,
+  buildMatchesRequest: () => buildMatchesRequest,
+  implementationsMatch: () => implementationsMatch,
+  pep440ConstraintsToString: () => pep440ConstraintsToString,
+  pythonVersionToString: () => pythonVersionToString,
+  selectPython: () => selectPython,
+  variantsMatch: () => variantsMatch
+});
+module.exports = __toCommonJS(python_selector_exports);
+var import_pep440 = require("./pep440");
+var import_python_specifiers = require("./python-specifiers");
+function selectPython(constraints, available) {
+  const warnings = [];
+  const errors = [];
+  if (constraints.length === 0) {
+    return {
+      build: available.length > 0 ? available[0] : null,
+      errors: available.length === 0 ? ["No Python builds available"] : void 0
+    };
+  }
+  const constraintMatches = /* @__PURE__ */ new Map();
+  for (let i = 0; i < constraints.length; i++) {
+    constraintMatches.set(i, []);
+  }
+  for (const build of available) {
+    let matchesAll = true;
+    for (let i = 0; i < constraints.length; i++) {
+      const constraint = constraints[i];
+      if (buildMatchesConstraint(build, constraint)) {
+        constraintMatches.get(i)?.push(build);
+      } else {
+        matchesAll = false;
+      }
+    }
+    if (matchesAll) {
+      return {
+        build,
+        warnings: warnings.length > 0 ? warnings : void 0
+      };
+    }
+  }
+  if (constraints.length > 1) {
+    const constraintsWithMatches = [];
+    for (let i = 0; i < constraints.length; i++) {
+      const matches = constraintMatches.get(i) ?? [];
+      if (matches.length > 0) {
+        constraintsWithMatches.push(i);
+      }
+    }
+    if (constraintsWithMatches.length > 1) {
+      const sources = constraintsWithMatches.map((i) => constraints[i].source);
+      warnings.push(
+        `Python version constraints may not overlap: ${sources.join(", ")}`
+      );
+    }
+  }
+  const constraintDescriptions = constraints.map((c) => c.source).join(", ");
+  errors.push(
+    `No Python build satisfies all constraints: ${constraintDescriptions}`
+  );
+  return {
+    build: null,
+    errors,
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
+}
+function pythonVersionToString(version) {
+  let str = `${version.major}.${version.minor}`;
+  if (version.patch !== void 0) {
+    str += `.${version.patch}`;
+  }
+  if (version.prerelease) {
+    str += version.prerelease;
+  }
+  return str;
+}
+function pep440ConstraintsToString(constraints) {
+  return constraints.map((c) => `${c.operator}${c.prefix}${c.version}`).join(",");
+}
+function implementationsMatch(buildImpl, requestImpl) {
+  if (import_python_specifiers.PythonImplementation.isUnknown(buildImpl)) {
+    if (import_python_specifiers.PythonImplementation.isUnknown(requestImpl)) {
+      return buildImpl.implementation === requestImpl.implementation;
+    }
+    return false;
+  }
+  if (import_python_specifiers.PythonImplementation.isUnknown(requestImpl)) {
+    return false;
+  }
+  return buildImpl === requestImpl;
+}
+function variantsMatch(buildVariant, requestVariant) {
+  if (typeof buildVariant === "object" && "type" in buildVariant) {
+    if (typeof requestVariant === "object" && "type" in requestVariant) {
+      return buildVariant.variant === requestVariant.variant;
+    }
+    return false;
+  }
+  if (typeof requestVariant === "object" && "type" in requestVariant) {
+    return false;
+  }
+  return buildVariant === requestVariant;
+}
+function buildMatchesRequest(build, request) {
+  if (request.implementation !== void 0) {
+    if (!implementationsMatch(build.implementation, request.implementation)) {
+      return false;
+    }
+  }
+  if (request.version !== void 0) {
+    const versionConstraints = request.version.constraint;
+    if (versionConstraints.length > 0) {
+      const buildVersionStr = pythonVersionToString(build.version);
+      const specifier = pep440ConstraintsToString(versionConstraints);
+      if (!(0, import_pep440.pep440Satisfies)(buildVersionStr, specifier)) {
+        return false;
+      }
+    }
+    if (request.version.variant !== void 0) {
+      if (!variantsMatch(build.variant, request.version.variant)) {
+        return false;
+      }
+    }
+  }
+  if (request.platform !== void 0) {
+    const platform = request.platform;
+    if (platform.os !== void 0) {
+      if (build.os.toLowerCase() !== platform.os.toLowerCase()) {
+        return false;
+      }
+    }
+    if (platform.arch !== void 0) {
+      if (build.architecture.toLowerCase() !== platform.arch.toLowerCase()) {
+        return false;
+      }
+    }
+    if (platform.libc !== void 0) {
+      if (build.libc.toLowerCase() !== platform.libc.toLowerCase()) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function buildMatchesConstraint(build, constraint) {
+  if (constraint.request.length === 0) {
+    return true;
+  }
+  for (const request of constraint.request) {
+    if (buildMatchesRequest(build, request)) {
+      return true;
+    }
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildMatchesConstraint,
+  buildMatchesRequest,
+  implementationsMatch,
+  pep440ConstraintsToString,
+  pythonVersionToString,
+  selectPython,
+  variantsMatch
+});

package/dist/manifest/python-specifiers.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Python specifier types for version, implementation, variant, and build information.
+ *
+ * These types are used internally for Python version selection and are not
+ * parsed from config files (no Zod schemas needed).
+ *
+ * @module python-specifiers
+ */
+import type { Pep440Constraint } from '@renovatebot/pep440';
+export type UnknownPythonImplementation = {
+    implementation: string;
+};
+export type PythonImplementation = 'cpython' | 'pypy' | 'pyodide' | 'graalpy' | UnknownPythonImplementation;
+export declare const PythonImplementation: {
+    knownLongNames(): Record<string, PythonImplementation>;
+    knownShortNames(): Record<string, PythonImplementation>;
+    knownNames(): Record<string, PythonImplementation>;
+    parse(s: string): PythonImplementation;
+    isUnknown(impl: PythonImplementation): impl is UnknownPythonImplementation;
+    toString(impl: PythonImplementation): string;
+    toStringPretty(impl: PythonImplementation): string;
+};
+export type PythonVariant = 'default' | 'debug' | 'freethreaded' | 'gil' | 'freethreaded+debug' | 'gil+debug' | {
+    type: 'unknown';
+    variant: string;
+};
+export declare const PythonVariant: {
+    parse(s: string): PythonVariant;
+    toString(v: PythonVariant): string;
+};
+export interface PythonRequest {
+    implementation?: PythonImplementation;
+    version?: PythonVersionRequest;
+    platform?: PythonPlatformRequest;
+}
+export interface PythonPlatformRequest {
+    os?: string;
+    arch?: string;
+    libc?: string;
+}
+export interface PythonVersionRequest {
+    constraint: Pep440Constraint[];
+    variant?: PythonVariant;
+}
+/**
+ * A Python version constraint with its source.
+ *
+ * Represents a requirement for a specific Python version range,
+ * along with information about where the constraint originated.
+ */
+export interface PythonConstraint {
+    /** The Python version request(s) that define this constraint. */
+    request: PythonRequest[];
+    /** Human-readable description of where this constraint came from. */
+    source: string;
+}
+export type PythonVersion = {
+    major: number;
+    minor: number;
+    patch?: number;
+    prerelease?: string;
+};
+export declare const PythonVersion: {
+    toString(version: PythonVersion): string;
+};
+export type PythonBuild = {
+    version: PythonVersion;
+    implementation: PythonImplementation;
+    variant: PythonVariant;
+    os: string;
+    architecture: string;
+    libc: string;
+};
+export declare const PythonBuild: {
+    toString(build: PythonBuild): string;
+};