@styx-api/core 0.5.0 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@styx-api/core",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Styx compiler core: parses CLI tool descriptors (e.g. Boutiques), optimizes an IR, solves typed parameter bindings, and generates type-safe wrappers (TypeScript, Python, JSON Schema). Part of the Styx/NiWrap ecosystem.",
   "keywords": [
     "styx",

package/src/backend/python/packaging.ts

@@ -72,17 +72,23 @@ function licenseField(proj: ProjectMeta): string {
 }
 
 /**
- * Per-suite `pyproject.toml`. The flat layout (`python/<pkg>/bet.py`) makes the
- * directory itself the importable package, so setuptools' `package-dir` maps the
- * import name (`<pkg>`) onto the distribution's root directory. The styxdefs
+ * Per-suite `pyproject.toml`. The suite source stays in a flat directory
+ * (`python/<pkg>/bet.py`), but setuptools' `package-dir` maps that directory onto
+ * the dotted import package `<project>.<pkg>`, so every suite nests under the
+ * metapackage's `<project>/` namespace. That restores `from <project> import
+ * <pkg>` while keeping each suite a separately-installable distribution (and
+ * leaves no top-level `<pkg>` polluting the global namespace). With no project
+ * name the import name is the bare `<pkg>` (top-level fallback). The styxdefs
  * floor is the only runtime dependency.
  *
- * Precondition: `pkg.name` must be a valid Python identifier - the flat layout's
- * relative imports (`from .bet import *`) already require this, and the CLI uses
- * it verbatim as the directory name, so this stays consistent with that.
+ * Precondition: `importName` is a valid (possibly dotted) Python package path -
+ * the caller scrubs the project + package names into identifiers accordingly.
  */
-export function generateSubPyproject(proj: ProjectMeta, pkg: PackageMeta): string {
-  const importName = pkgDir(pkg);
+export function generateSubPyproject(
+  proj: ProjectMeta,
+  pkg: PackageMeta,
+  importName: string,
+): string {
   const cb = new CodeBuilder("  ");
   cb.line("[project]");
   cb.line(`name = "${tomlStr(pyDistName(proj, pkg))}"`);
@@ -133,14 +139,28 @@ export function generateRootInitPy(): string {
 
 /**
  * Root `pyproject.toml`: a metapackage depending on `styxkit[all]` (the runner
- * stack it re-exports) plus each per-suite distribution. `packages` lists only
- * the metapackage's own module so setuptools ships the styxkit re-export without
- * sweeping the sibling suite directories into this distribution.
+ * stack it re-exports) plus each per-suite distribution, pinned to this exact
+ * project version (`niwrap_fsl==1.2.3`). The suites all ride the project version
+ * and ship in lockstep, so an exact pin keeps `pip install niwrap==X` consistent:
+ * during the post-release index-propagation window (or any momentary registry
+ * inconsistency) pip errors cleanly instead of silently grafting an older suite
+ * whose layout no longer matches the metapackage. Mirrors the way the CLI pins
+ * `@styx-api/core` exactly.
+ *
+ * `packages` lists only the metapackage's own module so setuptools ships the
+ * styxkit re-export without sweeping the sibling suite directories into this
+ * distribution. The module is the `<project>/` namespace package the suites nest
+ * into, so installing the metapackage makes `<project>.use_docker()` reachable
+ * alongside the suites' `from <project> import <pkg>`. `moduleDir` is the on-disk
+ * source directory; it differs from the import `moduleName` only when a suite is
+ * named after the project, in which case a `package-dir` remap keeps the import
+ * name intact.
  */
 export function generateRootPyproject(
   proj: ProjectMeta,
   distNames: string[],
   moduleName: string,
+  moduleDir: string,
 ): string {
   const cb = new CodeBuilder("  ");
   cb.line("[project]");
@@ -153,11 +173,17 @@ export function generateRootPyproject(
   cb.line(`requires-python = "${REQUIRES_PYTHON}"`);
   cb.line("dependencies = [");
   for (const dep of PYTHON_RUNNER_DEPS) cb.line(`  "${dep}",`);
-  for (const dist of distNames) cb.line(`  "${tomlStr(dist)}",`);
+  // Pin each suite to the exact project version (they ship in lockstep) so a
+  // mid-propagation install can't mix a new metapackage with an old suite.
+  const suitePin = tomlStr(proj.version ?? "0.0.0");
+  for (const dist of distNames) cb.line(`  "${tomlStr(dist)}==${suitePin}",`);
   cb.line("]");
   cb.blank();
   cb.line("[tool.setuptools]");
   cb.line(`packages = ["${moduleName}"]`);
+  if (moduleDir !== moduleName) {
+    cb.line(`package-dir = { "${moduleName}" = "${moduleDir}" }`);
+  }
   cb.blank();
   cb.line("[tool.setuptools.package-data]");
   cb.line(`"${moduleName}" = ["py.typed"]`);

package/src/backend/python/python.ts

@@ -547,6 +547,14 @@ export class PythonBackend implements Backend {
     const pkgDirs: string[] = [];
     const warnings: EmitWarning[] = [];
 
+    // The metapackage's importable module doubles as the namespace every suite
+    // nests under (`<project>.<suite>`), so `from <project> import <suite>` and
+    // `<project>.use_docker()` both resolve from one shared `<project>/` package.
+    // Scrub the project name to a valid, non-keyword identifier; with no project
+    // name there is no namespace and suites stay top-level (matching the bare
+    // distribution-name fallback in `pyDistName`).
+    const nsName = proj.name && proj.name.trim() ? pyScrubIdent(proj.name, PY_RESERVED) : undefined;
+
     for (const p of packages) {
       const pkg = p.meta ?? {};
       // Mirror the CLI's `pkgDir` fallback so a nameless package's source dir
@@ -554,27 +562,31 @@ export class PythonBackend implements Backend {
       const dir = pkg.name ?? "package";
       pkgDirs.push(dir);
       distNames.push(pyDistName(proj, pkg));
-      files.set(`${dir}/pyproject.toml`, generateSubPyproject(proj, pkg));
+      // Import package: `<project>.<suite>` so it shares the metapackage's
+      // namespace; setuptools maps the flat suite dir onto this dotted path.
+      const importPkg = nsName ? `${nsName}.${dir}` : dir;
+      files.set(`${dir}/pyproject.toml`, generateSubPyproject(proj, pkg, importPkg));
       files.set(`${dir}/README.md`, generateSubReadme(proj, pkg));
     }
 
-    // The metapackage ships its own importable module: a thin styxkit re-export
-    // so `import <project>; <project>.use_docker()` works (PEP 561 typed). Scrub
-    // the project name to a valid, non-keyword identifier, then dodge any suite
-    // directory so the stub never clobbers a suite's real wrapper module.
-    const rawMod = proj.name && proj.name.trim() ? proj.name : "project";
-    let rootMod = pyScrubIdent(rawMod, PY_RESERVED);
-    if (pkgDirs.includes(rootMod)) {
-      const collided = rootMod;
-      while (pkgDirs.includes(rootMod)) rootMod += "_";
+    // The metapackage ships `<project>/__init__.py` (a thin styxkit re-export so
+    // `<project>.use_docker()` works, PEP 561 typed) into the same `<project>/`
+    // package the suites nest under. Its on-disk source dir must dodge a suite
+    // named after the project (both would write `<project>/`); the import name
+    // stays `<project>` via a `package-dir` remap so the namespace is preserved.
+    const metaImport = nsName ?? "project";
+    let metaDir = metaImport;
+    if (pkgDirs.includes(metaDir)) {
+      const collided = metaDir;
+      while (pkgDirs.includes(metaDir)) metaDir += "_";
       warnings.push({
-        message: `metapackage module "${collided}" collides with a suite directory; emitting as "${rootMod}" instead`,
+        message: `metapackage directory "${collided}" collides with a suite directory; emitting its sources in "${metaDir}" instead (import name stays "${metaImport}")`,
       });
     }
-    files.set(`${rootMod}/__init__.py`, generateRootInitPy());
-    files.set(`${rootMod}/py.typed`, "");
+    files.set(`${metaDir}/__init__.py`, generateRootInitPy());
+    files.set(`${metaDir}/py.typed`, "");
 
-    files.set("pyproject.toml", generateRootPyproject(proj, distNames, rootMod));
+    files.set("pyproject.toml", generateRootPyproject(proj, distNames, metaImport, metaDir));
     files.set("README.md", generateRootReadme(proj, distNames));
     files.set("requirements.txt", generateRequirementsTxt(pkgDirs));