@mnci/nx-python-pip 0.1.1

package/README.md

@@ -0,0 +1,120 @@
+# @mnci/nx-python-pip
+
+An Nx plugin for **pip-native** Python projects — plain `pip`, Ruff, pytest
+and the standard PyPA `build`/`twine` tools. No uv, no Poetry, no lock file.
+
+## Why
+
+No maintained, Nx-23-compatible Python plugin supports pip: the closest
+existing option, [`@nxlv/python`](https://github.com/lucasvieirasilva/nx-plugins),
+ships only `uv` and Poetry providers, and every alternative found on npm is
+either the same uv/Poetry architecture or years stale. If your organization
+standardizes on plain pip (no uv, no Poetry), this plugin fills that gap.
+
+It was built for and is used by [`@mnci/cli`](../cli)'s `mnci2 add python-*`
+commands, but has no dependency on `@mnci/cli` — any Nx 21+ workspace can
+install and use it directly.
+
+## Install
+
+```sh
+npm install --save-dev @mnci/nx-python-pip
+```
+
+No `nx.json` `plugins` registration needed — its generators and executors
+are explicit (resolved via `generators.json`/`executors.json`, plain Node
+module lookup), not inference-based.
+
+You will also need the actual Python tools this plugin's executors shell out
+to: `python3 -m pip install build twine ruff pytest` (or pin them in your own
+`requirements-dev.txt` / `requirements-dev.in`). The plugin has no opinion on
+*how* those land on a machine — same way `@nx/js`'s executors assume `node`
+is already there.
+
+## Generators
+
+| Generator | Location default | Writes |
+| --- | --- | --- |
+| `application` | `apps/<name>` | `pyproject.toml` (hatchling) + `project.json` (`lint`/`test`/`build`) + a sample module and pytest |
+| `library` | `libs/<name>` | Same as `application`, plus `nx-release-publish` (twine) and a project-level `release.version.versionActions` override |
+| `internal-library` | `libs/<name>` | `lint`/`test` only — no `build`/publish; meant to be **vendored** into a consumer's wheel, not built or released on its own |
+| `function-application` | `apps/<name>` | Azure Functions **v2** programming model (`function_app.py` + `host.json` + `requirements.txt` + a tested pure helper) — no `pyproject.toml`/build target, since the deployable is source, not a wheel |
+
+```sh
+nx g @mnci/nx-python-pip:application my-app
+nx g @mnci/nx-python-pip:library my-lib --directory=packages/my-lib
+nx g @mnci/nx-python-pip:internal-library my-shared-lib
+nx g @mnci/nx-python-pip:function-application my-function-app
+```
+
+## Executors
+
+| Executor | Runs |
+| --- | --- |
+| `build` | `python -m build` — vendoring-aware (see below) |
+| `test` | `python -m pip install -e .` (unless `installEditable: false`) then `python -m pytest` |
+| `lint` | `python -m ruff check .` |
+| `publish` | `python -m twine upload --skip-existing dist/*`, reading `TWINE_USERNAME`/`TWINE_PASSWORD`/`TWINE_REPOSITORY_URL` from the environment |
+
+Every command is invoked as `python3 -m <tool>`, never a hard-coded venv
+path, so the exact same command works whether or not you've activated a
+virtualenv — this plugin never creates or manages one itself.
+
+`publish` accepts a real, typed `dryRun` option — `nx release publish
+--dry-run` sets it automatically on every `nx-release-publish` executor, so
+a dry run cleanly previews the twine command instead of running it.
+
+## Internal-lib vendoring
+
+Plain pip has no bundled-local-dependency feature (the equivalent of
+`@nxlv/python`'s `bundleLocalDependencies`). To have a project's built wheel
+bundle an internal library's module as a real top-level package, hand-add a
+`vendor` entry to the consuming project's `pyproject.toml`:
+
+```toml
+[tool.mnci-python-pip]
+vendor = ["my-shared-lib"]
+```
+
+The `build` executor resolves `my-shared-lib`'s root via the **real Nx
+project graph** (not a hard-coded path), copies its module directory into a
+staged copy of the project being built, patches the staged
+`pyproject.toml`'s `[tool.hatch.build.targets.wheel] packages` list to
+include it, and builds from there. No cross-project dependency is ever wired
+automatically — you always add this entry by hand, mirroring how you'd wire
+any other cross-project dependency.
+
+Verified empirically that vendoring an internal lib and declaring a real
+external PyPI dependency on the *same* project works correctly together —
+the combination that silently dropped the external dependency's metadata
+under `@nxlv/python`'s `bundleLocalDependencies` does not reproduce here.
+
+## Versioning (`nx release`)
+
+The `library` generator sets:
+
+```json
+"release": { "version": { "versionActions": "@mnci/nx-python-pip/release/version-actions" } }
+```
+
+on the generated project. This is a hand-written implementation of Nx's
+`VersionActions` interface that reads/writes the `version = "..."` line
+under `pyproject.toml`'s `[project]` table — verified empirically against a
+real `nx release version --dry-run`, both the disk-fallback and
+git-tag-based resolution paths. Internal-lib dependencies are vendored, not
+registry references, so dependency-version tracking is a no-op (the same
+branch `@nxlv/python`'s own reference implementation takes for bundled
+dependencies).
+
+## Known gaps
+
+- No lock file — plain pip has none. A published wheel's `Requires-Dist`
+  mirrors whatever specifier `pyproject.toml` declares (e.g. `tomli>=2.0.0`)
+  verbatim, not a resolved/pinned version.
+- Vendored internal-lib imports are only resolvable inside the **built**
+  wheel — not from a plain `pip install -e .` dev environment, since
+  vendoring happens at `build` time only. A project whose pytest-covered
+  code imports a vendored internal lib needs its own test-isolation
+  strategy; the `test` executor makes no attempt to solve this.
+- venv management is left to the user — same spirit as never managing
+  `node_modules` beyond `npm install`.

package/dist/executors/build/executor.d.ts

@@ -0,0 +1,25 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { BuildExecutorSchema } from './schema.d';
+/**
+ * Builds a Python project's wheel/sdist via `python -m build`.
+ *
+ * @remarks
+ * When the project's `pyproject.toml` declares a `vendor` entry (see
+ * `parseVendorEntries`), each named project's module directory is copied
+ * into a staged copy of the project before building, and the staged
+ * `pyproject.toml`'s wheel `packages` list is patched to include it — so the
+ * built wheel contains the vendored module as a real top-level package, with
+ * no separate install needed by whoever installs the published wheel.
+ * Projects with no `vendor` entry build straight from their own directory,
+ * no staging.
+ *
+ * @param _options - Unused (vendoring is driven by `pyproject.toml`, not options).
+ * @param context - The Nx executor context.
+ * @returns `{ success: true }` when `python -m build` exits 0.
+ * @throws Never - failures surface through the returned `success: false`.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export default function buildExecutor(_options: BuildExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;
+//# sourceMappingURL=executor.d.ts.map

package/dist/executors/build/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/executors/build/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAQjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAoBrD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAA8B,aAAa,CAAE,QAAQ,EAAE,mBAAmB,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAqCnI"}

package/dist/executors/build/executor.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = buildExecutor;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const executorContext_1 = require("../../internal/executorContext");
+const pythonProject_1 = require("../../internal/pythonProject");
+const vendor_1 = require("../../internal/vendor");
+/**
+ * Resolves a vendored project's workspace-relative root via the Nx project
+ * graph (not a hard-coded `libs/<name>` path) — the same lookup
+ * {@link projectRootFrom} uses for the project under build itself.
+ *
+ * @param name - The vendored project's Nx project name.
+ * @param context - The Nx executor context.
+ * @returns The workspace-relative root, or `undefined` when no project with
+ * that name is registered.
+ * @throws Never - an unresolvable name yields `undefined`, not a throw; the
+ * caller surfaces it as a normal `python -m build` failure (a missing
+ * source directory), not a confusing internal error.
+ * @typeParam None - this function has no generic type parameters.
+ */
+function vendoredProjectRoot(name, context) {
+    return context.projectsConfigurations?.projects[name]?.root;
+}
+/**
+ * Builds a Python project's wheel/sdist via `python -m build`.
+ *
+ * @remarks
+ * When the project's `pyproject.toml` declares a `vendor` entry (see
+ * `parseVendorEntries`), each named project's module directory is copied
+ * into a staged copy of the project before building, and the staged
+ * `pyproject.toml`'s wheel `packages` list is patched to include it — so the
+ * built wheel contains the vendored module as a real top-level package, with
+ * no separate install needed by whoever installs the published wheel.
+ * Projects with no `vendor` entry build straight from their own directory,
+ * no staging.
+ *
+ * @param _options - Unused (vendoring is driven by `pyproject.toml`, not options).
+ * @param context - The Nx executor context.
+ * @returns `{ success: true }` when `python -m build` exits 0.
+ * @throws Never - failures surface through the returned `success: false`.
+ * @typeParam None - this function has no generic type parameters.
+ */
+async function buildExecutor(_options, context) {
+    const projectRoot = (0, executorContext_1.projectRootFrom)(context);
+    const absoluteProjectRoot = (0, node_path_1.join)(context.root, projectRoot);
+    const outDirectory = (0, node_path_1.join)(absoluteProjectRoot, 'dist');
+    const pyprojectPath = (0, node_path_1.join)(absoluteProjectRoot, 'pyproject.toml');
+    const pyprojectToml = (0, node_fs_1.readFileSync)(pyprojectPath, 'utf8');
+    const vendorNames = (0, vendor_1.parseVendorEntries)(pyprojectToml);
+    if (vendorNames.length === 0) {
+        const result = (0, node_child_process_1.spawnSync)('python3', ['-m', 'build', '--outdir', outDirectory, absoluteProjectRoot], { stdio: 'inherit' });
+        return { success: result.status === 0 };
+    }
+    const stagingRoot = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'nx-python-pip-build-'));
+    try {
+        (0, node_fs_1.cpSync)(absoluteProjectRoot, stagingRoot, { recursive: true });
+        const moduleDirectories = [];
+        for (const name of vendorNames) {
+            const vendoredRoot = vendoredProjectRoot(name, context);
+            if (!vendoredRoot) {
+                console.error(`nx-python-pip build: vendored project "${name}" is not registered in this workspace.`);
+                return { success: false };
+            }
+            const moduleDirectory = (0, pythonProject_1.pythonModuleDirectory)(name);
+            (0, node_fs_1.cpSync)((0, node_path_1.join)(context.root, vendoredRoot, moduleDirectory), (0, node_path_1.join)(stagingRoot, moduleDirectory), { recursive: true });
+            moduleDirectories.push(moduleDirectory);
+        }
+        const stagedPyprojectPath = (0, node_path_1.join)(stagingRoot, 'pyproject.toml');
+        (0, node_fs_1.writeFileSync)(stagedPyprojectPath, (0, vendor_1.addPackagesToWheelTarget)((0, node_fs_1.readFileSync)(stagedPyprojectPath, 'utf8'), moduleDirectories));
+        const result = (0, node_child_process_1.spawnSync)('python3', ['-m', 'build', '--outdir', outDirectory, stagingRoot], { stdio: 'inherit' });
+        return { success: result.status === 0 };
+    }
+    finally {
+        (0, node_fs_1.rmSync)(stagingRoot, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=executor.js.map

package/dist/executors/build/executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.js","sourceRoot":"","sources":["../../../src/executors/build/executor.ts"],"names":[],"mappings":"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"}

package/dist/executors/build/schema.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "MnciNxPythonPipBuild",
+  "title": "Build a Python wheel/sdist with python -m build",
+  "description": "Runs `python -m build`. When the project's pyproject.toml declares [tool.mnci-python-pip] vendor = [...], the named libs/<name> modules are copied into a staged copy of the project first, so the built wheel bundles them as real top-level packages.",
+  "type": "object",
+  "properties": {},
+  "required": []
+}

package/dist/executors/lint/executor.d.ts

@@ -0,0 +1,20 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { LintExecutorSchema } from './schema.d';
+/**
+ * Runs `python3 -m ruff check .` in the project's own directory.
+ *
+ * @remarks
+ * `python3 -m ruff` (not a bare `ruff`) so it resolves whatever `python3`
+ * the caller has active — no hard-coded venv path, matching every other
+ * executor in this package.
+ *
+ * @param _options - Unused (ruff needs no per-project configuration here).
+ * @param context - The Nx executor context.
+ * @returns `{ success: true }` when ruff exits 0.
+ * @throws Never - failures surface through the returned `success: false`.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export default function lintExecutor(_options: LintExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;
+//# sourceMappingURL=executor.d.ts.map

package/dist/executors/lint/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/executors/lint/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAIjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD;;;;;;;;;;;;;GAaG;AACH,wBAA8B,YAAY,CAAE,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAIjI"}

package/dist/executors/lint/executor.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = lintExecutor;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const executorContext_1 = require("../../internal/executorContext");
+/**
+ * Runs `python3 -m ruff check .` in the project's own directory.
+ *
+ * @remarks
+ * `python3 -m ruff` (not a bare `ruff`) so it resolves whatever `python3`
+ * the caller has active — no hard-coded venv path, matching every other
+ * executor in this package.
+ *
+ * @param _options - Unused (ruff needs no per-project configuration here).
+ * @param context - The Nx executor context.
+ * @returns `{ success: true }` when ruff exits 0.
+ * @throws Never - failures surface through the returned `success: false`.
+ * @typeParam None - this function has no generic type parameters.
+ */
+async function lintExecutor(_options, context) {
+    const cwd = (0, node_path_1.join)(context.root, (0, executorContext_1.projectRootFrom)(context));
+    const result = (0, node_child_process_1.spawnSync)('python3', ['-m', 'ruff', 'check', '.'], { cwd, stdio: 'inherit' });
+    return { success: result.status === 0 };
+}
+//# sourceMappingURL=executor.js.map

package/dist/executors/lint/executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.js","sourceRoot":"","sources":["../../../src/executors/lint/executor.ts"],"names":[],"mappings":";;;AACA,2DAA8C;AAC9C,yCAAgC;AAChC,oEAAgE;AAGhE;;;;;;;;;;;;;GAaG;AACY,KAAK,uBAAwB,QAA4B,EAAE,OAAwB;IAChG,MAAM,GAAG,GAAG,IAAA,gBAAI,EAAC,OAAO,CAAC,IAAI,EAAE,IAAA,iCAAe,EAAC,OAAO,CAAC,CAAC,CAAA;IACxD,MAAM,MAAM,GAAG,IAAA,8BAAS,EAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAA;IAC5F,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAA;AACzC,CAAC"}

package/dist/executors/lint/schema.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "MnciNxPythonPipLint",
+  "title": "Lint a Python project with ruff",
+  "type": "object",
+  "properties": {},
+  "required": []
+}

package/dist/executors/publish/executor.d.ts

@@ -0,0 +1,30 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { PublishExecutorSchema } from './schema.d';
+/**
+ * Runs `python -m twine upload --skip-existing dist/*`.
+ *
+ * @remarks
+ * `--skip-existing` mirrors npm's own idempotent-publish behaviour (Nx's
+ * `@nx/js:release-publish` also tolerates a version already on the
+ * registry), so a re-run after a partial release failure does not
+ * hard-error on the packages that already made it. Credentials
+ * (`TWINE_USERNAME`/`TWINE_PASSWORD`/`TWINE_REPOSITORY_URL`) are read from
+ * the environment by twine itself — never written to disk here.
+ *
+ * `dryRun` is a real, typed executor option (unlike a plain
+ * `nx:run-commands` target, which would only see the `--dry-run` flag as an
+ * opaque, appended `--dryRun=true` string on the shell command line).
+ * `nx release publish` sets `dryRun` automatically for every
+ * `nx-release-publish` executor, custom or not, so no argv-parsing trick is
+ * needed to preview instead of uploading for real.
+ *
+ * @param options - Whether to preview instead of actually uploading.
+ * @param context - The Nx executor context.
+ * @returns `{ success: true }` on a successful (real or previewed) publish.
+ * @throws Never - failures surface through the returned `success: false`.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export default function publishExecutor(options: PublishExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;
+//# sourceMappingURL=executor.d.ts.map

package/dist/executors/publish/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/executors/publish/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAIjD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAEvD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAA8B,eAAe,CAAE,OAAO,EAAE,qBAAqB,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAWtI"}

package/dist/executors/publish/executor.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = publishExecutor;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const executorContext_1 = require("../../internal/executorContext");
+/**
+ * Runs `python -m twine upload --skip-existing dist/*`.
+ *
+ * @remarks
+ * `--skip-existing` mirrors npm's own idempotent-publish behaviour (Nx's
+ * `@nx/js:release-publish` also tolerates a version already on the
+ * registry), so a re-run after a partial release failure does not
+ * hard-error on the packages that already made it. Credentials
+ * (`TWINE_USERNAME`/`TWINE_PASSWORD`/`TWINE_REPOSITORY_URL`) are read from
+ * the environment by twine itself — never written to disk here.
+ *
+ * `dryRun` is a real, typed executor option (unlike a plain
+ * `nx:run-commands` target, which would only see the `--dry-run` flag as an
+ * opaque, appended `--dryRun=true` string on the shell command line).
+ * `nx release publish` sets `dryRun` automatically for every
+ * `nx-release-publish` executor, custom or not, so no argv-parsing trick is
+ * needed to preview instead of uploading for real.
+ *
+ * @param options - Whether to preview instead of actually uploading.
+ * @param context - The Nx executor context.
+ * @returns `{ success: true }` on a successful (real or previewed) publish.
+ * @throws Never - failures surface through the returned `success: false`.
+ * @typeParam None - this function has no generic type parameters.
+ */
+async function publishExecutor(options, context) {
+    if (options.dryRun) {
+        console.log('[dry-run] would run: python3 -m twine upload --skip-existing dist/*');
+        return { success: true };
+    }
+    const cwd = (0, node_path_1.join)(context.root, (0, executorContext_1.projectRootFrom)(context));
+    // No shell: true needed for the dist/* glob — twine globs its own path
+    // arguments internally, so this stays free of a shell-injection surface.
+    const result = (0, node_child_process_1.spawnSync)('python3', ['-m', 'twine', 'upload', '--skip-existing', 'dist/*'], { cwd, stdio: 'inherit' });
+    return { success: result.status === 0 };
+}
+//# sourceMappingURL=executor.js.map

package/dist/executors/publish/executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.js","sourceRoot":"","sources":["../../../src/executors/publish/executor.ts"],"names":[],"mappings":";;;AACA,2DAA8C;AAC9C,yCAAgC;AAChC,oEAAgE;AAGhE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACY,KAAK,0BAA2B,OAA8B,EAAE,OAAwB;IACrG,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACnB,OAAO,CAAC,GAAG,CAAC,qEAAqE,CAAC,CAAA;QAClF,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAA;IAC1B,CAAC;IAED,MAAM,GAAG,GAAG,IAAA,gBAAI,EAAC,OAAO,CAAC,IAAI,EAAE,IAAA,iCAAe,EAAC,OAAO,CAAC,CAAC,CAAA;IACxD,uEAAuE;IACvE,yEAAyE;IACzE,MAAM,MAAM,GAAG,IAAA,8BAAS,EAAC,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,QAAQ,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAA;IACtH,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAA;AACzC,CAAC"}

package/dist/executors/publish/schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "MnciNxPythonPipPublish",
+  "title": "Publish a Python wheel/sdist with twine",
+  "description": "Runs `python -m twine upload --skip-existing dist/*`. Credentials (TWINE_USERNAME/TWINE_PASSWORD/TWINE_REPOSITORY_URL) are read from the environment by twine itself. Detects the --dryRun flag `nx release publish --dry-run` appends and previews instead of uploading for real.",
+  "type": "object",
+  "properties": {
+    "dryRun": {
+      "type": "boolean",
+      "description": "Preview instead of actually uploading. Set automatically by `nx release publish --dry-run`.",
+      "default": false
+    }
+  },
+  "required": []
+}

package/dist/executors/test/executor.d.ts

@@ -0,0 +1,26 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { TestExecutorSchema } from './schema.d';
+/**
+ * Runs pytest for a Python project, optionally installing it in editable
+ * mode first so its own declared dependencies are importable.
+ *
+ * @remarks
+ * `pip install -e .` (when `installEditable` is not `false`) makes the
+ * project's `pyproject.toml` `dependencies` (real external PyPI packages)
+ * importable at test time. It does **not** make vendored internal-lib
+ * imports importable — those are woven in only at `build` time (see the
+ * `build` executor's remarks) — so a project whose pytest-covered code
+ * imports a vendored internal lib needs its own test isolation strategy;
+ * this executor makes no attempt to solve that.
+ *
+ * @param options - Whether to `pip install -e .` before pytest.
+ * @param context - The Nx executor context.
+ * @returns `{ success: true }` when pytest exits 0 (and, when requested, the
+ * editable install also succeeded).
+ * @throws Never - failures surface through the returned `success: false`.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export default function testExecutor(options: TestExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;
+//# sourceMappingURL=executor.d.ts.map

package/dist/executors/test/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/executors/test/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAIjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAA8B,YAAY,CAAE,OAAO,EAAE,kBAAkB,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAYhI"}

package/dist/executors/test/executor.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = testExecutor;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const executorContext_1 = require("../../internal/executorContext");
+/**
+ * Runs pytest for a Python project, optionally installing it in editable
+ * mode first so its own declared dependencies are importable.
+ *
+ * @remarks
+ * `pip install -e .` (when `installEditable` is not `false`) makes the
+ * project's `pyproject.toml` `dependencies` (real external PyPI packages)
+ * importable at test time. It does **not** make vendored internal-lib
+ * imports importable — those are woven in only at `build` time (see the
+ * `build` executor's remarks) — so a project whose pytest-covered code
+ * imports a vendored internal lib needs its own test isolation strategy;
+ * this executor makes no attempt to solve that.
+ *
+ * @param options - Whether to `pip install -e .` before pytest.
+ * @param context - The Nx executor context.
+ * @returns `{ success: true }` when pytest exits 0 (and, when requested, the
+ * editable install also succeeded).
+ * @throws Never - failures surface through the returned `success: false`.
+ * @typeParam None - this function has no generic type parameters.
+ */
+async function testExecutor(options, context) {
+    const cwd = (0, node_path_1.join)(context.root, (0, executorContext_1.projectRootFrom)(context));
+    if (options.installEditable !== false) {
+        const install = (0, node_child_process_1.spawnSync)('python3', ['-m', 'pip', 'install', '--quiet', '-e', '.'], { cwd, stdio: 'inherit' });
+        if (install.status !== 0) {
+            return { success: false };
+        }
+    }
+    const result = (0, node_child_process_1.spawnSync)('python3', ['-m', 'pytest'], { cwd, stdio: 'inherit' });
+    return { success: result.status === 0 };
+}
+//# sourceMappingURL=executor.js.map

package/dist/executors/test/executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.js","sourceRoot":"","sources":["../../../src/executors/test/executor.ts"],"names":[],"mappings":";;;AACA,2DAA8C;AAC9C,yCAAgC;AAChC,oEAAgE;AAGhE;;;;;;;;;;;;;;;;;;;GAmBG;AACY,KAAK,uBAAwB,OAA2B,EAAE,OAAwB;IAC/F,MAAM,GAAG,GAAG,IAAA,gBAAI,EAAC,OAAO,CAAC,IAAI,EAAE,IAAA,iCAAe,EAAC,OAAO,CAAC,CAAC,CAAA;IAExD,IAAI,OAAO,CAAC,eAAe,KAAK,KAAK,EAAE,CAAC;QACtC,MAAM,OAAO,GAAG,IAAA,8BAAS,EAAC,SAAS,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAA;QAC/G,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACzB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAA;QAC3B,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAG,IAAA,8BAAS,EAAC,SAAS,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAA;IAChF,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAA;AACzC,CAAC"}

package/dist/executors/test/schema.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "MnciNxPythonPipTest",
+  "title": "Test a Python project with pytest",
+  "type": "object",
+  "properties": {
+    "installEditable": {
+      "type": "boolean",
+      "description": "Run `pip install -e .` before pytest, so the project's own declared dependencies are importable. Set to false for projects with no pyproject.toml (e.g. an Azure Function app, which deploys as source, not a wheel).",
+      "default": true
+    }
+  },
+  "required": []
+}

package/dist/generators/application/generator.d.ts

@@ -0,0 +1,20 @@
+import type { Tree } from '@nx/devkit';
+import type { AppGeneratorSchema } from './schema.d';
+/**
+ * Generates a pip-native Python application: `pyproject.toml` + `project.json`
+ * (lint/test/build) + a sample module and pytest.
+ *
+ * @remarks
+ * No `nx-release-publish` target and no `release.version.versionActions`
+ * override — apps are never released by `nx release` (packed into a deploy
+ * artifact instead, by whatever `package`-style target the calling workspace
+ * layers on top).
+ *
+ * @param tree - The Nx virtual file system.
+ * @param options - The project name and directory.
+ * @returns A promise that resolves once generated files are formatted.
+ * @throws Never - pure Tree writes.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export default function appGenerator(tree: Tree, options: AppGeneratorSchema): Promise<void>;
+//# sourceMappingURL=generator.d.ts.map

package/dist/generators/application/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../src/generators/application/generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD;;;;;;;;;;;;;;;GAeG;AACH,wBAA8B,YAAY,CAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOlG"}

package/dist/generators/application/generator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = appGenerator;
+const generateProject_1 = require("../../internal/generateProject");
+/**
+ * Generates a pip-native Python application: `pyproject.toml` + `project.json`
+ * (lint/test/build) + a sample module and pytest.
+ *
+ * @remarks
+ * No `nx-release-publish` target and no `release.version.versionActions`
+ * override — apps are never released by `nx release` (packed into a deploy
+ * artifact instead, by whatever `package`-style target the calling workspace
+ * layers on top).
+ *
+ * @param tree - The Nx virtual file system.
+ * @param options - The project name and directory.
+ * @returns A promise that resolves once generated files are formatted.
+ * @throws Never - pure Tree writes.
+ * @typeParam None - this function has no generic type parameters.
+ */
+async function appGenerator(tree, options) {
+    (0, generateProject_1.generateBuildableProject)(tree, {
+        name: options.name,
+        directory: options.directory ?? `apps/${options.name}`,
+        projectType: 'application',
+    });
+    await (0, generateProject_1.formatFiles)(tree);
+}
+//# sourceMappingURL=generator.js.map

package/dist/generators/application/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../src/generators/application/generator.ts"],"names":[],"mappings":";;;AACA,oEAAsF;AAGtF;;;;;;;;;;;;;;;GAeG;AACY,KAAK,uBAAwB,IAAU,EAAE,OAA2B;IACjF,IAAA,0CAAwB,EAAC,IAAI,EAAE;QAC7B,IAAI,EAAS,OAAO,CAAC,IAAI;QACzB,SAAS,EAAI,OAAO,CAAC,SAAS,IAAI,QAAQ,OAAO,CAAC,IAAI,EAAE;QACxD,WAAW,EAAE,aAAa;KAC3B,CAAC,CAAA;IACF,MAAM,IAAA,6BAAW,EAAC,IAAI,CAAC,CAAA;AACzB,CAAC"}

package/dist/generators/application/schema.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "MnciNxPythonPipApplication",
+  "title": "Create a Python application",
+  "description": "Hand-authors a pip-native Python app: pyproject.toml (hatchling) + project.json (lint/test/build targets) + a sample module and pytest.",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The project name.",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-prompt": "What name would you like to use?",
+      "pattern": "^[a-zA-Z][^:]*$"
+    },
+    "directory": {
+      "type": "string",
+      "description": "Workspace-relative directory for the project (defaults to apps/<name>)."
+    }
+  },
+  "required": ["name"]
+}

package/dist/generators/functionApplication/generator.d.ts

@@ -0,0 +1,21 @@
+import { type Tree } from '@nx/devkit';
+import type { FunctionAppGeneratorSchema } from './schema.d';
+/**
+ * Generates a Python Azure Function app (v2 programming model): `function_app.py`
+ * + `host.json` + `requirements.txt` + a tested pure helper module.
+ *
+ * @remarks
+ * No `pyproject.toml`/`build` target: the deployable is the **source tree**
+ * (Azure's Python worker installs `requirements.txt` and runs
+ * `function_app.py` directly — Oryx build at deploy time, no wheel), so this
+ * generator writes no build system at all. `func` CLI is not needed to
+ * generate — only for local `func start`.
+ *
+ * @param tree - The Nx virtual file system.
+ * @param options - The project name and directory.
+ * @returns A promise that resolves once generated files are formatted.
+ * @throws Never - pure Tree writes.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export default function functionAppGenerator(tree: Tree, options: FunctionAppGeneratorSchema): Promise<void>;
+//# sourceMappingURL=generator.d.ts.map

package/dist/generators/functionApplication/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../src/generators/functionApplication/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwC,KAAK,IAAI,EAAE,MAAM,YAAY,CAAA;AAS5E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAA8B,oBAAoB,CAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBlH"}