metascope 0.1.0 → 0.2.0

package/dist/lib/sources/publiccode-yaml.js

@@ -0,0 +1,256 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl, stringArray } from "../utilities/schema-primitives.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { z } from "zod";
+import { parse } from "yaml";
+//#region src/lib/sources/publiccode-yaml.ts
+/**
+* Source and parser for `publiccode.yml` / `publiccode.yaml` files.
+*
+* Publiccode.yml is a metadata standard for public software repositories,
+* primarily used in Europe (Italy, Netherlands, etc.).
+* See: https://yml.publiccode.tools/
+*
+* Extracts project metadata including name, version, license, contacts,
+* multi-language descriptions, dependencies, and categorization.
+*/
+const publiccodeContactEntrySchema = z.object({
+	affiliation: z.string().optional(),
+	email: z.string().optional(),
+	name: z.string(),
+	phone: z.string().optional()
+});
+const publiccodeContractorEntrySchema = z.object({
+	name: z.string(),
+	until: z.string().optional(),
+	website: z.string().optional()
+});
+const publiccodeDependencyEntrySchema = z.object({
+	category: z.enum([
+		"hardware",
+		"open",
+		"proprietary"
+	]),
+	name: z.string(),
+	optional: z.boolean().optional(),
+	version: z.string().optional(),
+	versionMax: z.string().optional(),
+	versionMin: z.string().optional()
+});
+const publiccodeDescriptionSchema = z.object({
+	documentation: z.string().optional(),
+	features: z.array(z.string()),
+	genericName: z.string().optional(),
+	localisedName: z.string().optional(),
+	longDescription: z.string().optional(),
+	shortDescription: z.string().optional()
+});
+const publiccodeSchema = z.object({
+	applicationSuite: nonEmptyString,
+	availableLanguages: stringArray,
+	categories: stringArray,
+	contacts: z.array(publiccodeContactEntrySchema),
+	contractors: z.array(publiccodeContractorEntrySchema),
+	dependencies: z.array(publiccodeDependencyEntrySchema),
+	description: publiccodeDescriptionSchema.optional(),
+	descriptions: z.record(z.string(), publiccodeDescriptionSchema),
+	developmentStatus: nonEmptyString,
+	inputTypes: stringArray,
+	isBasedOn: optionalUrl,
+	landingUrl: optionalUrl,
+	license: nonEmptyString,
+	localisationReady: z.boolean().optional(),
+	logo: optionalUrl,
+	mainCopyrightOwner: nonEmptyString,
+	maintenanceType: nonEmptyString,
+	monochromeLogo: optionalUrl,
+	name: nonEmptyString,
+	outputTypes: stringArray,
+	platforms: stringArray,
+	publiccodeYmlVersion: nonEmptyString,
+	releaseDate: nonEmptyString,
+	repoOwner: nonEmptyString,
+	roadmap: optionalUrl,
+	softwareType: nonEmptyString,
+	softwareVersion: nonEmptyString,
+	url: optionalUrl,
+	usedBy: stringArray
+});
+/** Coerce YAML values that may be parsed as non-strings back to strings. */
+function toString(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return String(value);
+	if (value instanceof Date) return value.toISOString().slice(0, 10);
+}
+/** Check if a value is a non-empty string. */
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+/** Check if a value is a plain object (not null, not array). */
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+/** Extract string array from a YAML value, filtering non-strings. */
+function toStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string");
+}
+/** Parse a description block from a publiccode description object. */
+function parseDescription(data) {
+	const features = [];
+	if (Array.isArray(data.features)) {
+		for (const feature of data.features) if (typeof feature === "string") features.push(feature);
+		else if (isPlainObject(feature)) for (const [key, value] of Object.entries(feature)) features.push(typeof value === "string" ? `${key}: ${value}` : key);
+	}
+	return {
+		...isNonEmptyString(data.documentation) ? { documentation: data.documentation } : {},
+		features,
+		...isNonEmptyString(data.genericName) ? { genericName: data.genericName } : {},
+		...isNonEmptyString(data.localisedName) ? { localisedName: data.localisedName } : {},
+		...isNonEmptyString(data.longDescription) ? { longDescription: data.longDescription.trim() } : {},
+		...isNonEmptyString(data.shortDescription) ? { shortDescription: data.shortDescription.trim() } : {}
+	};
+}
+/**
+* Parse a publiccode.yml / publiccode.yaml file content.
+* @param content - Raw YAML file content.
+* @returns Parsed publiccode metadata, or `undefined` if the content is invalid.
+*/
+function parse$1(content) {
+	let data;
+	try {
+		data = parse(content);
+	} catch {
+		return;
+	}
+	if (!isPlainObject(data)) return void 0;
+	if (!isNonEmptyString(data.name) && !isNonEmptyString(data.url)) return void 0;
+	const descriptions = {};
+	let description;
+	if (isPlainObject(data.description)) {
+		const descObject = data.description;
+		for (const [lang, langData] of Object.entries(descObject)) if (isPlainObject(langData)) descriptions[lang] = parseDescription(langData);
+		const preferredLang = "en" in descriptions ? "en" : Object.keys(descriptions)[0];
+		if (preferredLang) description = descriptions[preferredLang];
+	}
+	const contacts = [];
+	if (isPlainObject(data.maintenance)) {
+		const { maintenance } = data;
+		if (Array.isArray(maintenance.contacts)) {
+			for (const contact of maintenance.contacts) if (isPlainObject(contact) && isNonEmptyString(contact.name)) {
+				const entry = { name: contact.name };
+				if (isNonEmptyString(contact.email)) entry.email = contact.email;
+				if (isNonEmptyString(contact.phone)) entry.phone = contact.phone;
+				if (isNonEmptyString(contact.affiliation)) entry.affiliation = contact.affiliation;
+				contacts.push(entry);
+			}
+		}
+	}
+	const contractors = [];
+	if (isPlainObject(data.maintenance)) {
+		const { maintenance } = data;
+		if (Array.isArray(maintenance.contractors)) {
+			for (const contractor of maintenance.contractors) if (isPlainObject(contractor) && isNonEmptyString(contractor.name)) {
+				const entry = { name: contractor.name };
+				const until = toString(contractor.until);
+				if (until) entry.until = until;
+				if (isNonEmptyString(contractor.website)) entry.website = contractor.website;
+				contractors.push(entry);
+			}
+		}
+	}
+	const dependencies = [];
+	if (isPlainObject(data.dependsOn)) {
+		const { dependsOn } = data;
+		for (const category of [
+			"open",
+			"proprietary",
+			"hardware"
+		]) {
+			const categoryDeps = dependsOn[category];
+			if (Array.isArray(categoryDeps)) {
+				for (const dep of categoryDeps) if (isPlainObject(dep) && isNonEmptyString(dep.name)) {
+					const entry = {
+						category,
+						name: dep.name
+					};
+					const version = toString(dep.version);
+					if (version) entry.version = version;
+					const versionMin = toString(dep.versionMin);
+					if (versionMin) entry.versionMin = versionMin;
+					const versionMax = toString(dep.versionMax);
+					if (versionMax) entry.versionMax = versionMax;
+					if (typeof dep.optional === "boolean") entry.optional = dep.optional;
+					dependencies.push(entry);
+				}
+			}
+		}
+	}
+	let availableLanguages = [];
+	let localisationReady;
+	if (isPlainObject(data.localisation)) {
+		const loc = data.localisation;
+		availableLanguages = toStringArray(loc.availableLanguages);
+		if (typeof loc.localisationReady === "boolean") localisationReady = loc.localisationReady;
+	}
+	let license;
+	let mainCopyrightOwner;
+	let repoOwner;
+	if (isPlainObject(data.legal)) {
+		const { legal } = data;
+		if (isNonEmptyString(legal.license)) license = legal.license;
+		if (isNonEmptyString(legal.mainCopyrightOwner)) mainCopyrightOwner = legal.mainCopyrightOwner;
+		if (isNonEmptyString(legal.repoOwner)) repoOwner = legal.repoOwner;
+	}
+	const version = toString(data.softwareVersion);
+	const releaseDate = toString(data.releaseDate);
+	return publiccodeSchema.parse({
+		...isNonEmptyString(data.applicationSuite) ? { applicationSuite: data.applicationSuite } : {},
+		availableLanguages,
+		categories: toStringArray(data.categories),
+		contacts,
+		contractors,
+		dependencies,
+		...description ? { description } : {},
+		descriptions,
+		...isNonEmptyString(data.developmentStatus) ? { developmentStatus: data.developmentStatus } : {},
+		inputTypes: toStringArray(data.inputTypes),
+		...isNonEmptyString(data.isBasedOn) ? { isBasedOn: data.isBasedOn } : {},
+		...isNonEmptyString(data.landingURL) ? { landingUrl: data.landingURL } : {},
+		...license ? { license } : {},
+		...localisationReady === void 0 ? {} : { localisationReady },
+		...isNonEmptyString(data.logo) ? { logo: data.logo } : {},
+		...mainCopyrightOwner ? { mainCopyrightOwner } : {},
+		...isPlainObject(data.maintenance) && isNonEmptyString(data.maintenance.type) ? { maintenanceType: data.maintenance.type } : {},
+		...isNonEmptyString(data.monochromeLogo) ? { monochromeLogo: data.monochromeLogo } : {},
+		...isNonEmptyString(data.name) ? { name: data.name } : {},
+		outputTypes: toStringArray(data.outputTypes),
+		platforms: toStringArray(data.platforms),
+		...isNonEmptyString(data.publiccodeYmlVersion) ? { publiccodeYmlVersion: data.publiccodeYmlVersion } : toString(data.publiccodeYmlVersion) ? { publiccodeYmlVersion: toString(data.publiccodeYmlVersion) } : {},
+		...releaseDate ? { releaseDate } : {},
+		...repoOwner ? { repoOwner } : {},
+		...isNonEmptyString(data.roadmap) ? { roadmap: data.roadmap } : {},
+		...isNonEmptyString(data.softwareType) ? { softwareType: data.softwareType } : {},
+		...version ? { softwareVersion: version } : {},
+		...isNonEmptyString(data.url) ? { url: data.url } : {},
+		usedBy: toStringArray(data.usedBy)
+	});
+}
+const publiccodeYamlSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["publiccode.yml", "publiccode.yaml"]);
+	},
+	key: "publiccodeYaml",
+	async parse(input, context) {
+		const data = parse$1(await readFile(resolve(context.options.path, input), "utf8"));
+		if (data !== void 0) return {
+			data,
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { publiccodeYamlSource };

package/dist/lib/sources/python-pkg-info.d.ts

@@ -0,0 +1,31 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/python-pkg-info.d.ts
+/** Parsed PKG-INFO / METADATA metadata */
+declare const pkgInfoDataSchema: z.ZodObject<{
+  author: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  author_email: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  classifiers: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  description_content_type: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  download_url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  home_page: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  license: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  long_description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  maintainer: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  maintainer_email: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  metadata_version: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  platforms: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  project_urls: z.ZodRecord<z.ZodString, z.ZodString>;
+  requires_dist: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  requires_python: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  summary: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  version: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+type PkgInfo = z.infer<typeof pkgInfoDataSchema>;
+type PythonPkgInfoData = OneOrMany<SourceRecord<PkgInfo>> | undefined;
+//#endregion
+export { PythonPkgInfoData };

package/dist/lib/sources/python-pkg-info.js

@@ -0,0 +1,115 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { nonEmptyString, optionalUrl, stringArray } from "../utilities/schema-primitives.js";
+import { splitCommaSeparated } from "../utilities/template-helpers.js";
+import { extractRfc822Body, parseRfc822Headers, splitMultiValues } from "../parsers/rfc822-header-parser.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { z } from "zod";
+//#region src/lib/sources/python-pkg-info.ts
+/** Parsed PKG-INFO / METADATA metadata */
+const pkgInfoDataSchema = z.object({
+	author: nonEmptyString,
+	author_email: nonEmptyString,
+	classifiers: stringArray,
+	description: nonEmptyString,
+	description_content_type: nonEmptyString,
+	download_url: optionalUrl,
+	home_page: optionalUrl,
+	keywords: z.array(z.string()).optional(),
+	license: nonEmptyString,
+	long_description: nonEmptyString,
+	maintainer: nonEmptyString,
+	maintainer_email: nonEmptyString,
+	metadata_version: nonEmptyString,
+	name: nonEmptyString,
+	platforms: stringArray,
+	project_urls: z.record(z.string(), z.string()),
+	requires_dist: stringArray,
+	requires_python: nonEmptyString,
+	summary: nonEmptyString,
+	version: nonEmptyString
+});
+/** Simple header-to-field mappings. */
+const HEADER_MAP = {
+	Author: "author",
+	"Author-email": "author_email",
+	"Description-Content-Type": "description_content_type",
+	"Download-URL": "download_url",
+	"Home-Page": "home_page",
+	"Home-page": "home_page",
+	License: "license",
+	Maintainer: "maintainer",
+	"Maintainer-email": "maintainer_email",
+	"Metadata-Version": "metadata_version",
+	Name: "name",
+	"Requires-Python": "requires_python",
+	Summary: "summary",
+	Version: "version"
+};
+/**
+* Parse a PKG-INFO or METADATA file and return structured metadata.
+*
+* Handles RFC 822-style headers with multi-value fields (Classifier,
+* Requires-Dist, Project-URL, Platform), continuation lines, and
+* the body section as long_description.
+*/
+function parse(source) {
+	const headers = parseRfc822Headers(source);
+	const data = {
+		author: void 0,
+		author_email: void 0,
+		classifiers: [],
+		description: void 0,
+		description_content_type: void 0,
+		download_url: void 0,
+		home_page: void 0,
+		keywords: void 0,
+		license: void 0,
+		long_description: void 0,
+		maintainer: void 0,
+		maintainer_email: void 0,
+		metadata_version: void 0,
+		name: void 0,
+		platforms: [],
+		project_urls: {},
+		requires_dist: [],
+		requires_python: void 0,
+		summary: void 0,
+		version: void 0
+	};
+	for (const [header, field] of Object.entries(HEADER_MAP)) {
+		const value = headers[header];
+		if (value && value !== "UNKNOWN") Object.assign(data, { [field]: value });
+	}
+	if (headers.Summary && headers.Summary !== "UNKNOWN") data.description = headers.Summary;
+	if (headers.Keywords && headers.Keywords !== "UNKNOWN") data.keywords = splitCommaSeparated(headers.Keywords);
+	data.classifiers = splitMultiValues(headers.Classifier);
+	data.platforms = splitMultiValues(headers.Platform);
+	data.requires_dist = splitMultiValues(headers["Requires-Dist"]);
+	if (headers["Project-URL"]) for (const line of splitMultiValues(headers["Project-URL"])) {
+		const commaIndex = line.indexOf(", ");
+		if (commaIndex > 0) {
+			const label = line.slice(0, commaIndex).trim();
+			const url = line.slice(commaIndex + 2).trim();
+			if (url) data.project_urls[label] = url;
+		}
+	}
+	data.long_description = extractRfc822Body(source);
+	return pkgInfoDataSchema.parse(data);
+}
+const pythonPkgInfoSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["PKG-INFO"]);
+	},
+	key: "pythonPkgInfo",
+	async parse(input, context) {
+		return {
+			data: parse(await readFile(resolve(context.options.path, input), "utf8")),
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { pythonPkgInfoSource };

package/dist/lib/sources/python-pypi-registry.d.ts

@@ -0,0 +1,19 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+
+//#region src/lib/sources/python-pypi-registry.d.ts
+type PythonPypiRegistryInfo = {
+  /** Total downloads over the last 180 days. */downloads180Days?: number; /** Downloads in the last day. */
+  downloadsDaily?: number; /** Downloads in the last month. */
+  downloadsMonthly?: number; /** Downloads in the last week. */
+  downloadsWeekly?: number; /** ISO 8601 date the package was last published. */
+  publishDateLatest?: string; /** Total number of releases on PyPI. */
+  releaseCount?: number; /** Size in bytes of the latest release artifact. */
+  sizeBytes?: number; /** PyPI project URL. */
+  url?: string; /** Latest published version string. */
+  versionLatest?: string; /** Whether the latest version has been yanked. */
+  yanked?: boolean; /** Reason the version was yanked, if provided. */
+  yankedReason?: string;
+};
+type PythonPypiRegistryData = OneOrMany<SourceRecord<PythonPypiRegistryInfo>> | undefined;
+//#endregion
+export { PythonPypiRegistryData };

package/dist/lib/sources/python-pypi-registry.js

@@ -0,0 +1,101 @@
+import { log } from "../log.js";
+import { defineSource } from "../source.js";
+import { ensureArray } from "../utilities/template-helpers.js";
+import { fetchWithRetry } from "../utilities/fetch.js";
+import { pythonPkgInfoSource } from "./python-pkg-info.js";
+import { pythonPyprojectTomlSource } from "./python-pyproject-toml.js";
+import { pythonSetupCfgSource } from "./python-setup-cfg.js";
+import { pythonSetupPySource } from "./python-setup-py.js";
+import { z } from "zod";
+//#region src/lib/sources/python-pypi-registry.ts
+const pypiResponseSchema = z.object({
+	info: z.object({
+		version: z.string(),
+		yanked: z.boolean().optional(),
+		yanked_reason: z.string().nullable().optional()
+	}),
+	releases: z.record(z.string(), z.array(z.unknown())),
+	urls: z.array(z.object({
+		size: z.number().optional(),
+		upload_time_iso_8601: z.string().optional()
+	}))
+});
+const pypistatsRecentSchema = z.object({ data: z.object({
+	last_day: z.number(),
+	last_month: z.number(),
+	last_week: z.number()
+}) });
+const pypistatsOverallSchema = z.object({ data: z.array(z.object({
+	category: z.string(),
+	downloads: z.number()
+})) });
+const pythonPypiRegistrySource = defineSource({
+	async discover(context) {
+		let packageNames = [];
+		packageNames = ensureArray(context.metadata?.pythonPyprojectToml).map((value) => value.data.project?.name).filter((value) => value !== void 0);
+		if (packageNames.length === 0) packageNames = ensureArray(context.metadata?.pythonSetupCfg).map((value) => value.data.name).filter((value) => value !== void 0);
+		if (packageNames.length === 0) packageNames = ensureArray(context.metadata?.pythonSetupPy).map((value) => value.data.name).filter((value) => value !== void 0);
+		if (packageNames.length === 0) packageNames = ensureArray(context.metadata?.pythonPkgInfo).map((value) => value.data.name).filter((value) => value !== void 0);
+		if (packageNames.length === 0) {
+			if (![
+				"pythonPyprojectToml",
+				"pythonSetupCfg",
+				"pythonSetupPy",
+				"pythonPkgInfo"
+			].some((key) => context.completedSources?.has(key))) {
+				log.warn(`Missing python package names in source context metadata for ${context.options.path}, extracting them now...`);
+				packageNames = ensureArray(await pythonPyprojectTomlSource.extract(context)).map((value) => value.data.project?.name).filter((value) => value !== void 0);
+				if (packageNames.length === 0) packageNames = ensureArray(await pythonSetupCfgSource.extract(context)).map((value) => value.data.name).filter((value) => value !== void 0);
+				if (packageNames.length === 0) packageNames = ensureArray(await pythonSetupPySource.extract(context)).map((value) => value.data.name).filter((value) => value !== void 0);
+				if (packageNames.length === 0) packageNames = ensureArray(await pythonPkgInfoSource.extract(context)).map((value) => value.data.name).filter((value) => value !== void 0);
+			}
+		}
+		return packageNames;
+	},
+	key: "pythonPypiRegistry",
+	async parse(input) {
+		log.debug("Extracting PyPI metadata...");
+		const name = input;
+		const [pypiResult, pypistatsRecentResult, pypistatsOverallResult] = await Promise.all([
+			fetchWithRetry(`https://pypi.org/pypi/${encodeURIComponent(name)}/json`).then(async (response) => {
+				if (!response.ok) return;
+				return pypiResponseSchema.parse(await response.json());
+			}).catch(() => void 0),
+			fetchWithRetry(`https://pypistats.org/api/packages/${encodeURIComponent(name)}/recent`).then(async (response) => {
+				if (!response.ok) return;
+				return pypistatsRecentSchema.parse(await response.json());
+			}).catch(() => void 0),
+			fetchWithRetry(`https://pypistats.org/api/packages/${encodeURIComponent(name)}/overall?mirrors=false`).then(async (response) => {
+				if (!response.ok) return;
+				return pypistatsOverallSchema.parse(await response.json());
+			}).catch(() => void 0)
+		]);
+		if (!pypiResult) return;
+		const latestUploadTime = pypiResult.urls[0]?.upload_time_iso_8601;
+		const sizeBytes = pypiResult.urls[0]?.size;
+		const info = {
+			publishDateLatest: latestUploadTime,
+			releaseCount: Object.keys(pypiResult.releases).length,
+			sizeBytes,
+			url: `https://pypi.org/project/${encodeURIComponent(name)}/`,
+			versionLatest: pypiResult.info.version
+		};
+		if (pypiResult.info.yanked) {
+			info.yanked = true;
+			if (pypiResult.info.yanked_reason) info.yankedReason = pypiResult.info.yanked_reason;
+		}
+		if (pypistatsRecentResult) {
+			info.downloadsDaily = pypistatsRecentResult.data.last_day;
+			info.downloadsMonthly = pypistatsRecentResult.data.last_month;
+			info.downloadsWeekly = pypistatsRecentResult.data.last_week;
+		}
+		if (pypistatsOverallResult) info.downloads180Days = pypistatsOverallResult.data.reduce((sum, entry) => sum + entry.downloads, 0) || void 0;
+		return {
+			data: info,
+			source: `https://pypi.org/project/${encodeURIComponent(name)}/`
+		};
+	},
+	phase: 2
+});
+//#endregion
+export { pythonPypiRegistrySource };

package/dist/lib/sources/python-pyproject-toml.d.ts

@@ -0,0 +1,7 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { PyprojectData } from "read-pyproject";
+
+//#region src/lib/sources/python-pyproject-toml.d.ts
+type PythonPyprojectTomlData = OneOrMany<SourceRecord<PyprojectData>> | undefined;
+//#endregion
+export { PythonPyprojectTomlData };

package/dist/lib/sources/python-pyproject-toml.js

@@ -0,0 +1,30 @@
+import { getMatches } from "../file-matching.js";
+import { defineSource } from "../source.js";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { parsePyproject } from "read-pyproject";
+//#region src/lib/sources/python-pyproject-toml.ts
+/**
+* Parse pyproject.toml content and return structured metadata.
+*/
+function parse(content) {
+	return parsePyproject(content, {
+		camelCase: true,
+		unknownKeyPolicy: "strip"
+	});
+}
+const pythonPyprojectTomlSource = defineSource({
+	async discover(context) {
+		return getMatches(context.options, ["pyproject.toml"]);
+	},
+	key: "pythonPyprojectToml",
+	async parse(input, context) {
+		return {
+			data: parse(await readFile(resolve(context.options.path, input), "utf8")),
+			source: input
+		};
+	},
+	phase: 1
+});
+//#endregion
+export { pythonPyprojectTomlSource };

package/dist/lib/sources/python-setup-cfg.d.ts

@@ -0,0 +1,28 @@
+import { OneOrMany, SourceRecord } from "../source.js";
+import { z } from "zod";
+
+//#region src/lib/sources/python-setup-cfg.d.ts
+declare const setupCfgDataSchema: z.ZodObject<{
+  author: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  author_email: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  classifiers: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  download_url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  extras_require: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+  install_requires: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+  keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  license: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  long_description: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  maintainer: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  maintainer_email: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  name: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  project_urls: z.ZodRecord<z.ZodString, z.ZodString>;
+  python_requires: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  url: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+  version: z.ZodPipe<z.ZodTransform<string | undefined, unknown>, z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+/** Parsed setup.cfg metadata */
+type SetupCfg = z.infer<typeof setupCfgDataSchema>;
+type PythonSetupCfgData = OneOrMany<SourceRecord<SetupCfg>> | undefined;
+//#endregion
+export { PythonSetupCfgData };