@dbx-tools/projen 0.6.223 → 0.6.225

package/tasks/uniffi-python.d.ts

@@ -0,0 +1,56 @@
+export interface TomlCodec {
+  parse(source: string): unknown;
+  stringify(document: unknown): string;
+}
+
+export interface PythonPackageMapping {
+  readonly directory: string;
+  readonly name: string;
+}
+
+export interface PythonProjectInfo {
+  readonly name: string;
+  readonly private: boolean;
+}
+
+/** Read the project identity and publication flag from parsed TOML metadata. */
+export function pythonProjectInfo(source: string, toml: TomlCodec): PythonProjectInfo;
+
+/** Stamp a temporary publication version and exact sibling dependencies. */
+export function stampPythonProject(
+  source: string,
+  options: {
+    readonly packages: readonly PythonPackageMapping[];
+    readonly rewriteDependencies?: boolean;
+    readonly toml: TomlCodec;
+    readonly version: string;
+  },
+): string;
+
+/** Return the target-specific UniFFI generator executable name. */
+export function pythonBindingGeneratorName(crate: string, platform: string): string;
+
+/** Build the canonical UniFFI Python generator argument list. */
+export function pythonBindingGeneratorArgs(options: {
+  readonly crate: string;
+  readonly library: string;
+  readonly output: string;
+}): string[];
+
+export interface InstalledPythonBindings {
+  readonly bindings: string;
+  readonly init: string;
+  readonly library: string;
+}
+
+/** Generate and place one Python binding module and its native library. */
+export function installPythonBindings(options: {
+  readonly crate: string;
+  readonly library: string;
+  readonly module: string;
+  readonly packageRoot: string;
+  readonly platform: string;
+  readonly readonly?: boolean;
+  readonly run: (command: string, args: string[]) => void;
+  readonly targetDirectory: string;
+}): InstalledPythonBindings;

package/tasks/uniffi-python.js

@@ -0,0 +1,160 @@
+import {
+  chmodSync,
+  cpSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join, resolve } from "node:path";
+
+const READONLY = 0o444;
+const WRITABLE = 0o644;
+
+const projectTable = (document) => {
+  const project = document?.project;
+  if (!project || typeof project !== "object" || Array.isArray(project)) {
+    throw new Error("Missing Python project metadata");
+  }
+  return project;
+};
+
+const directSibling = (dependency, sibling) => {
+  const prefix = `${sibling.name} @ git+`;
+  if (!dependency.startsWith(prefix)) return false;
+  const marker = "#subdirectory=";
+  const markerIndex = dependency.indexOf(marker, prefix.length);
+  if (markerIndex < 0) return false;
+  const directory = dependency.slice(markerIndex + marker.length);
+  return directory === sibling.directory || directory.endsWith(`/${sibling.directory}`);
+};
+
+const setWritable = (path) => {
+  if (existsSync(path)) chmodSync(path, WRITABLE);
+};
+
+const setReadonly = (path) => {
+  if (existsSync(path)) chmodSync(path, READONLY);
+};
+
+const generatedHeader = (crate) =>
+  [
+    "# GENERATED by UniFFI binding generation - DO NOT EDIT.",
+    `# Regenerated from the ${crate} Rust exports.`,
+    "# Hand edits are overwritten on the next watch; this file is read-only.",
+    "",
+  ].join("\n");
+
+export const pythonProjectInfo = (source, toml) => {
+  const document = toml.parse(source);
+  const project = projectTable(document);
+  if (typeof project.name !== "string" || !project.name) {
+    throw new Error("Missing Python project name");
+  }
+  const config = document?.tool?.["dbx-tools"];
+  return {
+    name: project.name,
+    private: Boolean(config && typeof config === "object" && config.private === true),
+  };
+};
+
+export const stampPythonProject = (
+  source,
+  { packages, rewriteDependencies = true, toml, version },
+) => {
+  const marker = source.startsWith("# ") ? source.slice(0, source.indexOf("\n")) : undefined;
+  const document = toml.parse(source);
+  const project = projectTable(document);
+  if (typeof project.version !== "string") {
+    throw new Error("Missing Python project version");
+  }
+  project.version = version;
+  if (rewriteDependencies) {
+    const dependencies = project.dependencies;
+    if (dependencies !== undefined && !Array.isArray(dependencies)) {
+      throw new Error("Python project dependencies must be an array");
+    }
+    if (dependencies) {
+      project.dependencies = dependencies.map((dependency) => {
+        if (typeof dependency !== "string") {
+          throw new Error("Python project dependencies must be strings");
+        }
+        const sibling = packages.find((candidate) => directSibling(dependency, candidate));
+        return sibling ? `${sibling.name}==${version}` : dependency;
+      });
+    }
+  }
+  const body = toml.stringify(document).trimEnd();
+  return `${marker ? `${marker}\n\n` : ""}${body}\n`;
+};
+
+export const pythonBindingGeneratorName = (crate, platform) =>
+  `${crate}-uniffi-bindgen${platform === "win32" ? ".exe" : ""}`;
+
+export const pythonBindingGeneratorArgs = ({ crate, library, output }) => [
+  "generate",
+  "--language",
+  "python",
+  "--crate",
+  crate.replaceAll("-", "_"),
+  "--out-dir",
+  output,
+  library,
+];
+
+export const installPythonBindings = ({
+  crate,
+  library,
+  module,
+  packageRoot,
+  platform,
+  readonly = false,
+  run,
+  targetDirectory,
+}) => {
+  const packageName = module.split(".").at(-1);
+  if (!packageName) throw new Error(`Invalid Python module ${module}`);
+  const packageDirectory = resolve(packageRoot, "src", ...module.split("."));
+  const generatedDirectory = mkdtempSync(join(tmpdir(), `${packageName}-python-`));
+  const generator = resolve(targetDirectory, pythonBindingGeneratorName(crate, platform));
+  if (!existsSync(generator)) throw new Error(`Missing UniFFI generator ${generator}`);
+
+  try {
+    run(
+      generator,
+      pythonBindingGeneratorArgs({
+        crate,
+        library,
+        output: generatedDirectory,
+      }),
+    );
+    const generated = join(generatedDirectory, `${crate.replaceAll("-", "_")}.py`);
+    if (!existsSync(generated)) throw new Error(`Missing generated binding ${generated}`);
+    mkdirSync(packageDirectory, { recursive: true });
+
+    const bindings = join(packageDirectory, "bindings.py");
+    setWritable(bindings);
+    writeFileSync(bindings, `${generatedHeader(crate)}${readFileSync(generated, "utf8")}`);
+
+    const init = join(packageDirectory, "__init__.py");
+    setWritable(init);
+    writeFileSync(init, "");
+
+    const nativeLibrary = join(packageDirectory, basename(library));
+    setWritable(nativeLibrary);
+    cpSync(library, nativeLibrary);
+
+    if (readonly) {
+      setReadonly(bindings);
+      setReadonly(init);
+      setReadonly(nativeLibrary);
+    }
+    rmSync(join(packageDirectory, "_generated"), { recursive: true, force: true });
+    return { bindings, init, library: nativeLibrary };
+  } finally {
+    rmSync(generatedDirectory, { recursive: true, force: true });
+  }
+};

package/tasks/uniffi-release.mjs

@@ -14,8 +14,14 @@ import {
 import { basename, dirname, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 import { parseArgs } from "node:util";
 import { spawnSync } from "node:child_process";
+import { installPythonBindings, stampPythonProject } from "./uniffi-python.js";
+
+const require = createRequire(import.meta.url);
+const bundledToml = fileURLToPath(new URL("./smol-toml.cjs", import.meta.url));
+const toml = require(existsSync(bundledToml) ? bundledToml : "smol-toml");
 
 const parsed = parseArgs({
   allowPositionals: true,
@@ -215,9 +221,6 @@ const testNodeFacade = ({
   }
 };
 
-const replaceVersion = (source, version) =>
-  source.replace(/^version = "[^"]+"$/m, `version = "${version}"`);
-
 /** Resolve workspace and generated catalog protocols for a publishable facade. */
 const facadeDependency = (name, dependency, version, catalog) => {
   if (typeof dependency !== "string") return dependency;
@@ -411,57 +414,30 @@ const packagePython = ({
   cpSync(resolve(root, pythonDirectory), pythonRoot, { recursive: true });
   const pyproject = join(pythonRoot, "pyproject.toml");
   writable(pyproject);
-  writeFileSync(pyproject, replaceVersion(readFileSync(pyproject, "utf8"), version));
   const workspaceBindings =
     JSON.parse(readFileSync(join(root, "package.json"), "utf8")).dbxToolsConfig?.rust?.bindings ??
     [];
-  let metadata = readFileSync(pyproject, "utf8");
-  for (const binding of workspaceBindings) {
-    if (!binding.pythonPackage) continue;
-    const escaped = binding.pythonPackage.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    metadata = metadata.replace(
-      new RegExp(`"${escaped} @ git\\+[^"\\n]+"`, "g"),
-      JSON.stringify(`${binding.pythonPackage}==${version}`),
-    );
-  }
-  writeFileSync(pyproject, metadata);
-
-  const packageName = pythonModule.split(".").at(-1);
-  if (!packageName) throw new Error(`Invalid Python module ${pythonModule}`);
-  const packageDirectory = resolve(pythonRoot, "src", ...pythonModule.split("."));
-  const generatedDirectory = mkdtempSync(join(tmpdir(), `${packageName}-python-`));
-  const generator = resolve(
-    cargoTargetRoot,
-    cargoTarget,
-    "release",
-    `${crate}-uniffi-bindgen${os === "win32" ? ".exe" : ""}`,
-  );
-  if (!existsSync(generator)) throw new Error(`Missing UniFFI generator ${generator}`);
-  run(generator, [
-    "generate",
-    "--language",
-    "python",
-    "--crate",
-    crate.replaceAll("-", "_"),
-    "--out-dir",
-    generatedDirectory,
-    library,
-  ]);
-  const bindings = join(packageDirectory, "bindings.py");
-  writable(bindings);
-  const body = readFileSync(join(generatedDirectory, `${crate.replaceAll("-", "_")}.py`), "utf8");
   writeFileSync(
-    bindings,
-    [
-      "# GENERATED by UniFFI binding generation - DO NOT EDIT.",
-      `# Regenerated from the ${crate} Rust exports.`,
-      "# Hand edits are overwritten on the next watch; this file is read-only.",
-      "",
-      body,
-    ].join("\n"),
+    pyproject,
+    stampPythonProject(readFileSync(pyproject, "utf8"), {
+      packages: workspaceBindings.flatMap((binding) =>
+        binding.pythonPackage && binding.python
+          ? [{ name: binding.pythonPackage, directory: binding.python }]
+          : [],
+      ),
+      toml,
+      version,
+    }),
   );
-  cpSync(library, join(packageDirectory, basename(library)));
-  rmSync(generatedDirectory, { recursive: true, force: true });
+  installPythonBindings({
+    crate,
+    library,
+    module: pythonModule,
+    packageRoot: pythonRoot,
+    platform: os,
+    run,
+    targetDirectory: resolve(cargoTargetRoot, cargoTarget, "release"),
+  });
 
   const wheelDirectory = resolve(output, "python");
   mkdirSync(wheelDirectory, { recursive: true });

package/tasks/uniffi.ts

@@ -15,6 +15,7 @@ import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
+import { installPythonBindings } from "./uniffi-python.js";
 import { makeReadonly, makeWritable, stampGenerated } from "../src/generated.ts";
 import type { RustWorkspaceMapping } from "../src/project-rs.ts";
 import {
@@ -110,22 +111,6 @@ const replaceGenerated = (source: string, destination: string): void => {
   }
 };
 
-const stampGeneratedPython = (file: string): void => {
-  makeWritable(file);
-  const body = readFileSync(file, "utf8");
-  writeFileSync(
-    file,
-    [
-      "# GENERATED by UniFFI binding generation - DO NOT EDIT.",
-      `# Regenerated from the ${crate} Rust exports.`,
-      "# Hand edits are overwritten on the next watch; this file is read-only.",
-      "",
-      body,
-    ].join("\n"),
-  );
-  makeReadonly(file);
-};
-
 if (!values["skip-build"]) {
   run("cargo", [
     "build",
@@ -265,33 +250,14 @@ if (values.python) {
   if (!values["python-module"]) {
     throw new Error("Expected --python-module with --python");
   }
-  const pythonPackage = resolve(root, values.python, "src", ...values["python-module"].split("."));
-  const pythonOutput = mkdtempSync(join(tmpdir(), `${libraryName}-python-`));
-  run(
-    join(targetDirectory, `${crate}-uniffi-bindgen${process.platform === "win32" ? ".exe" : ""}`),
-    [
-      "generate",
-      "--language",
-      "python",
-      "--crate",
-      libraryName,
-      "--out-dir",
-      pythonOutput,
-      library,
-    ],
-  );
-  const generated = join(pythonOutput, `${libraryName}.py`);
-  const pythonBindings = join(pythonPackage, "bindings.py");
-  replaceGenerated(generated, pythonBindings);
-  stampGeneratedPython(pythonBindings);
-  const pythonInit = join(pythonPackage, "__init__.py");
-  makeWritable(pythonInit);
-  writeFileSync(pythonInit, "");
-  makeReadonly(pythonInit);
-  const pythonLibrary = join(pythonPackage, basename(library));
-  makeWritable(pythonLibrary);
-  cpSync(library, pythonLibrary);
-  makeReadonly(pythonLibrary);
-  rmSync(join(pythonPackage, "_generated"), { recursive: true, force: true });
-  rmSync(pythonOutput, { recursive: true, force: true });
+  installPythonBindings({
+    crate,
+    library,
+    module: values["python-module"],
+    packageRoot: resolve(root, values.python),
+    platform: process.platform,
+    readonly: true,
+    run,
+    targetDirectory,
+  });
 }