@dbx-tools/projen 0.9.17 → 0.9.19

package/tasks/publish-python.ts

@@ -2,6 +2,7 @@
 import {
   chmodSync,
   existsSync,
+  mkdirSync,
   mkdtempSync,
   readFileSync,
   readdirSync,
@@ -29,10 +30,19 @@ interface PythonProjectFile {
 }
 
 export interface StampPythonProjectsOptions {
+  readonly excludeUniFFI?: boolean;
   readonly rewriteDependencies?: boolean;
   readonly versions?: ReadonlyMap<string, string>;
 }
 
+/** Python wheel and source archives accepted by Twine and package indexes. */
+export function pythonDistributionPaths(directory: string): string[] {
+  return readdirSync(directory)
+    .filter((file) => file.endsWith(".whl") || file.endsWith(".tar.gz"))
+    .sort()
+    .map((file) => join(directory, file));
+}
+
 export interface RestorePythonProjects {
   (): void;
   readonly paths: readonly string[];
@@ -63,7 +73,10 @@ export function stampPythonProjects(
     };
   });
   const projects = allProjects.filter(
-    (project) => !project.private && (!options.versions || options.versions.has(project.directory)),
+    (project) =>
+      !project.private &&
+      (!options.excludeUniFFI || !project.uniffi) &&
+      (!options.versions || options.versions.has(project.directory)),
   );
   if (projects.length === 0) throw new Error(`No Python packages found under ${root}`);
 
@@ -110,12 +123,65 @@ export function publishPythonProjects(options: {
   readonly version: string;
   readonly plan?: ReleasePlan;
 }): void {
-  const root = resolve(options.root);
   const output = mkdtempSync(join(tmpdir(), "projen-python-publish-"));
+  try {
+    buildPythonProjects({ ...options, output });
+    exec.spawnSync(
+      "uvx",
+      [
+        "--from",
+        "devpi-client",
+        "devpi",
+        "upload",
+        "--index",
+        options.publishUrl,
+        "--from-dir",
+        ...(options.dryRun ? ["--dry-run"] : []),
+        output,
+      ],
+      {
+        cwd: process.cwd(),
+        env: { ...process.env, UV_DEFAULT_INDEX: options.indexUrl },
+        stdout: "inherit",
+        stderr: "inherit",
+        stdin: "ignore",
+        check: true,
+      },
+    );
+  } finally {
+    rmSync(output, { recursive: true, force: true });
+  }
+}
+
+/** Build the exact Python release distributions without publishing them. */
+export function buildPythonProjects(options: {
+  readonly allowEmpty?: boolean;
+  readonly excludeUniFFI?: boolean;
+  readonly output: string;
+  readonly root: string;
+  readonly version: string;
+  readonly plan?: ReleasePlan;
+}): void {
+  const root = resolve(options.root);
+  const output = resolve(options.output);
+  rmSync(output, { recursive: true, force: true });
+  const standardProjects = options.excludeUniFFI
+    ? readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => resolve(root, entry.name, "pyproject.toml"))
+        .filter(existsSync)
+        .map((path) => pythonProjectInfo(readFileSync(path, "utf8"), { parse, stringify }))
+        .filter((project) => !project.private && !project.uniffi)
+    : undefined;
+  if (standardProjects?.length === 0 && options.allowEmpty) {
+    mkdirSync(output, { recursive: true });
+    return;
+  }
   const planned = new Map(
     options.plan?.pythonPackages.map((pkg) => [pkg.path.replace(/^.*\//, ""), pkg.version]) ?? [],
   );
   const stamp = stampPythonProjects(root, options.version, {
+    excludeUniFFI: options.excludeUniFFI,
     ...(options.plan ? { versions: planned } : {}),
   });
   try {
@@ -130,6 +196,16 @@ export function publishPythonProjects(options: {
           check: true,
         });
       }
+    } else if (options.excludeUniFFI) {
+      for (const project of standardProjects ?? []) {
+        exec.spawnSync("uv", ["build", "--package", project.name, "--out-dir", output], {
+          cwd: process.cwd(),
+          stdout: "inherit",
+          stderr: "inherit",
+          stdin: "ignore",
+          check: true,
+        });
+      }
     } else {
       exec.spawnSync("uv", ["build", "--all-packages", "--out-dir", output], {
         cwd: process.cwd(),
@@ -139,31 +215,19 @@ export function publishPythonProjects(options: {
         check: true,
       });
     }
-    exec.spawnSync(
-      "uvx",
-      [
-        "--from",
-        "devpi-client",
-        "devpi",
-        "upload",
-        "--index",
-        options.publishUrl,
-        "--from-dir",
-        ...(options.dryRun ? ["--dry-run"] : []),
-        output,
-      ],
-      {
-        cwd: process.cwd(),
-        env: { ...process.env, UV_DEFAULT_INDEX: options.indexUrl },
-        stdout: "inherit",
-        stderr: "inherit",
-        stdin: "ignore",
-        check: true,
-      },
-    );
+    const distributions = pythonDistributionPaths(output);
+    if (distributions.length === 0) {
+      throw new Error(`No Python distributions found in ${output}`);
+    }
+    exec.spawnSync("uvx", ["twine", "check", ...distributions], {
+      cwd: process.cwd(),
+      stdout: "inherit",
+      stderr: "inherit",
+      stdin: "ignore",
+      check: true,
+    });
   } finally {
     stamp();
-    rmSync(output, { recursive: true, force: true });
   }
 }
 
@@ -175,6 +239,7 @@ if (import.meta.main) {
     .requiredOption("--publish-url <url>", "devpi writable index URL")
     .option("--root <path>", "Python workspace package root", "packages/py")
     .option("--plan <path>", "affected release plan")
+    .option("--output <path>", "Build distributions into a directory without publishing")
     .option("--dry-run", "build and inspect distributions without uploading")
     .action(
       (
@@ -185,6 +250,7 @@ if (import.meta.main) {
           publishUrl: string;
           root: string;
           plan?: string;
+          output?: string;
         },
       ) => {
         const plan = options.plan
@@ -192,7 +258,16 @@ if (import.meta.main) {
           : undefined;
         const fallbackVersion = version ?? plan?.pythonPackages[0]?.version;
         if (!fallbackVersion) throw new Error("Python publication requires a version or plan");
-        publishPythonProjects({ ...options, version: fallbackVersion, plan });
+        if (options.output) {
+          buildPythonProjects({
+            output: options.output,
+            root: options.root,
+            version: fallbackVersion,
+            plan,
+          });
+        } else {
+          publishPythonProjects({ ...options, version: fallbackVersion, plan });
+        }
       },
     );
   await program.parseAsync();

package/tasks/publish.ts

@@ -55,7 +55,9 @@
  */
 import {
   chmodSync,
+  copyFileSync,
   existsSync,
+  mkdirSync,
   mkdtempSync,
   readFileSync,
   rmSync,
@@ -234,12 +236,14 @@ const plan =
     : undefined;
 if (!version && !plan) {
   logger.error(
-    "usage: bun tasks/publish.ts <version> [--plan <path>] [--registry <url>] [--exclude <dir>] [--dry-run] [--skip-compile]",
+    "usage: bun tasks/publish.ts <version> [--plan <path>] [--registry <url>] [--output <dir>] [--exclude <dir>] [--dry-run] [--skip-compile]",
   );
   process.exit(1);
 }
 const registryIdx = rest.indexOf("--registry");
 const registry = registryIdx >= 0 ? rest[registryIdx + 1] : undefined;
+const outputIdx = rest.indexOf("--output");
+const output = outputIdx >= 0 ? resolve(root, rest[outputIdx + 1]) : undefined;
 const dryRun = rest.includes("--dry-run");
 const skipCompile = rest.includes("--skip-compile");
 const concurrencyIdx = rest.indexOf("--concurrency");
@@ -371,8 +375,12 @@ for (const { dir } of publishable) {
 }
 
 logger.info(
-  `${dryRun ? "dry-run packing" : "publishing"} ${publishable.length} packages with concurrency ${concurrency}`,
+  `${output ? "packing" : dryRun ? "dry-run packing" : "publishing"} ${publishable.length} packages with concurrency ${concurrency}`,
 );
+if (output) {
+  rmSync(output, { recursive: true, force: true });
+  mkdirSync(output, { recursive: true });
+}
 await asyncUtils.mapConcurrent(
   publishable,
   async ({ dir, name, version: packageVersion, access }) => {
@@ -390,6 +398,15 @@ await asyncUtils.mapConcurrent(
           `Packed npm access ${String(local.access)} does not match ${String(access)} for ${name}`,
         );
       }
+      if (output) {
+        const destination = join(output, archive.split(/[\\/]/).at(-1)!);
+        if (existsSync(destination)) {
+          throw new Error(`Duplicate npm archive name: ${destination}`);
+        }
+        copyFileSync(archive, destination);
+        logger.info(`packed ${name} @ ${packageVersion}`);
+        return;
+      }
       if (!dryRun) {
         const published = await publishedNpmRelease(local.name, local.version, registry);
         if (npmReleaseMatches(local, published)) {
@@ -410,4 +427,6 @@ await asyncUtils.mapConcurrent(
   },
   { concurrency, errorMode: "settle" },
 );
-logger.success(`${dryRun ? "dry-run: packed" : "published"} ${publishable.length} packages`);
+logger.success(
+  `${output || dryRun ? "packed" : "published"} ${publishable.length} packages${output ? ` to ${output}` : ""}`,
+);