@mnci/nx-python-pip 0.1.1

package/dist/generators/functionApplication/generator.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = functionAppGenerator;
+const devkit_1 = require("@nx/devkit");
+const azureFunctionApp_1 = require("../../internal/azureFunctionApp");
+const pythonProject_1 = require("../../internal/pythonProject");
+/**
+ * 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.
+ */
+async function functionAppGenerator(tree, options) {
+    const root = options.directory ?? `apps/${options.name}`;
+    const moduleDirectory = (0, pythonProject_1.pythonModuleDirectory)(options.name);
+    (0, devkit_1.addProjectConfiguration)(tree, options.name, {
+        root,
+        projectType: 'application',
+        sourceRoot: root,
+        targets: {
+            lint: { executor: '@mnci/nx-python-pip:lint', options: {} },
+            test: { executor: '@mnci/nx-python-pip:test', options: { installEditable: false } },
+        },
+    });
+    tree.write(`${root}/function_app.py`, (0, azureFunctionApp_1.pythonFunctionAppMain)(moduleDirectory));
+    tree.write(`${root}/host.json`, azureFunctionApp_1.PYTHON_FUNCTION_APP_HOST_JSON);
+    tree.write(`${root}/requirements.txt`, azureFunctionApp_1.PYTHON_FUNCTION_APP_REQUIREMENTS);
+    tree.write(`${root}/${moduleDirectory}/greeting.py`, azureFunctionApp_1.PYTHON_FUNCTION_APP_GREETING);
+    tree.write(`${root}/tests/test_greeting.py`, (0, azureFunctionApp_1.pythonFunctionAppGreetingTest)(moduleDirectory));
+    await (0, devkit_1.formatFiles)(tree);
+}
+//# sourceMappingURL=generator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../src/generators/functionApplication/generator.ts"],"names":[],"mappings":";;;AAAA,uCAA4E;AAC5E,sEAMwC;AACxC,gEAAoE;AAGpE;;;;;;;;;;;;;;;;GAgBG;AACY,KAAK,+BAAgC,IAAU,EAAE,OAAmC;IACjG,MAAM,IAAI,GAAG,OAAO,CAAC,SAAS,IAAI,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAA;IACxD,MAAM,eAAe,GAAG,IAAA,qCAAqB,EAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IAE3D,IAAA,gCAAuB,EAAC,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE;QAC1C,IAAI;QACJ,WAAW,EAAE,aAAa;QAC1B,UAAU,EAAG,IAAI;QACjB,OAAO,EAAM;YACX,IAAI,EAAE,EAAE,QAAQ,EAAE,0BAA0B,EAAE,OAAO,EAAE,EAAE,EAAE;YAC3D,IAAI,EAAE,EAAE,QAAQ,EAAE,0BAA0B,EAAE,OAAO,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,EAAE;SACpF;KACF,CAAC,CAAA;IAEF,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,kBAAkB,EAAE,IAAA,wCAAqB,EAAC,eAAe,CAAC,CAAC,CAAA;IAC7E,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,YAAY,EAAE,gDAA6B,CAAC,CAAA;IAC9D,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,mBAAmB,EAAE,mDAAgC,CAAC,CAAA;IACxE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI,eAAe,cAAc,EAAE,+CAA4B,CAAC,CAAA;IAClF,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,yBAAyB,EAAE,IAAA,gDAA6B,EAAC,eAAe,CAAC,CAAC,CAAA;IAC5F,MAAM,IAAA,oBAAW,EAAC,IAAI,CAAC,CAAA;AACzB,CAAC"}

package/dist/generators/functionApplication/schema.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "MnciNxPythonPipFunctionApplication",
+  "title": "Create a Python Azure Function app (v2 programming model)",
+  "description": "Hand-authors an Azure Functions v2 Python app: function_app.py + host.json + requirements.txt + a tested pure helper. No pyproject.toml/wheel build — the deployable is the source tree, not a wheel.",
+  "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/internalLibrary/generator.d.ts

@@ -0,0 +1,20 @@
+import { type Tree } from '@nx/devkit';
+import type { InternalLibraryGeneratorSchema } from './schema.d';
+/**
+ * Generates a private, never-published Python library: `pyproject.toml` +
+ * `project.json` (lint/test only) + a sample module and pytest.
+ *
+ * @remarks
+ * No `build` target: an internal lib is never built or packaged on its own —
+ * a consumer vendors its module directly into its own wheel at build time by
+ * hand-adding a `[tool.mnci-python-pip] vendor = ["<this-lib>"]` entry to its
+ * own `pyproject.toml` (see the `build` executor).
+ *
+ * @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 internalLibraryGenerator(tree: Tree, options: InternalLibraryGeneratorSchema): Promise<void>;
+//# sourceMappingURL=generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../src/generators/internalLibrary/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwC,KAAK,IAAI,EAAE,MAAM,YAAY,CAAA;AAE5E,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAA;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,wBAA8B,wBAAwB,CAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,8BAA8B,GAAG,OAAO,CAAC,IAAI,CAAC,CAkB1H"}

package/dist/generators/internalLibrary/generator.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = internalLibraryGenerator;
+const devkit_1 = require("@nx/devkit");
+const pythonProject_1 = require("../../internal/pythonProject");
+/**
+ * Generates a private, never-published Python library: `pyproject.toml` +
+ * `project.json` (lint/test only) + a sample module and pytest.
+ *
+ * @remarks
+ * No `build` target: an internal lib is never built or packaged on its own —
+ * a consumer vendors its module directly into its own wheel at build time by
+ * hand-adding a `[tool.mnci-python-pip] vendor = ["<this-lib>"]` entry to its
+ * own `pyproject.toml` (see the `build` executor).
+ *
+ * @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 internalLibraryGenerator(tree, options) {
+    const root = options.directory ?? `libs/${options.name}`;
+    const moduleDirectory = (0, pythonProject_1.pythonModuleDirectory)(options.name);
+    (0, devkit_1.addProjectConfiguration)(tree, options.name, {
+        root,
+        projectType: 'library',
+        sourceRoot: root,
+        targets: {
+            lint: { executor: '@mnci/nx-python-pip:lint', options: {} },
+            test: { executor: '@mnci/nx-python-pip:test', options: {} },
+        },
+    });
+    tree.write(`${root}/pyproject.toml`, (0, pythonProject_1.pythonPyprojectToml)(options.name, moduleDirectory));
+    tree.write(`${root}/${moduleDirectory}/__init__.py`, (0, pythonProject_1.pythonSampleModule)(moduleDirectory));
+    tree.write(`${root}/tests/test_${moduleDirectory}.py`, (0, pythonProject_1.pythonSampleTest)(moduleDirectory));
+    await (0, devkit_1.formatFiles)(tree);
+}
+//# sourceMappingURL=generator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../src/generators/internalLibrary/generator.ts"],"names":[],"mappings":";;;AAAA,uCAA4E;AAC5E,gEAA+H;AAG/H;;;;;;;;;;;;;;;GAeG;AACY,KAAK,mCAAoC,IAAU,EAAE,OAAuC;IACzG,MAAM,IAAI,GAAG,OAAO,CAAC,SAAS,IAAI,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAA;IACxD,MAAM,eAAe,GAAG,IAAA,qCAAqB,EAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IAE3D,IAAA,gCAAuB,EAAC,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE;QAC1C,IAAI;QACJ,WAAW,EAAE,SAAS;QACtB,UAAU,EAAG,IAAI;QACjB,OAAO,EAAM;YACX,IAAI,EAAE,EAAE,QAAQ,EAAE,0BAA0B,EAAE,OAAO,EAAE,EAAE,EAAE;YAC3D,IAAI,EAAE,EAAE,QAAQ,EAAE,0BAA0B,EAAE,OAAO,EAAE,EAAE,EAAE;SAC5D;KACF,CAAC,CAAA;IAEF,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,iBAAiB,EAAE,IAAA,mCAAmB,EAAC,OAAO,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC,CAAA;IACxF,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI,eAAe,cAAc,EAAE,IAAA,kCAAkB,EAAC,eAAe,CAAC,CAAC,CAAA;IACzF,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,eAAe,eAAe,KAAK,EAAE,IAAA,gCAAgB,EAAC,eAAe,CAAC,CAAC,CAAA;IACzF,MAAM,IAAA,oBAAW,EAAC,IAAI,CAAC,CAAA;AACzB,CAAC"}

package/dist/generators/internalLibrary/schema.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "MnciNxPythonPipInternalLibrary",
+  "title": "Create a private, never-published Python library",
+  "description": "Hand-authors a private Python library: pyproject.toml + project.json (lint/test only, no build/publish target) + a sample module and pytest. Consumers vendor its module into their own wheel at build time via [tool.mnci-python-pip] vendor = [...].",
+  "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 libs/<name>)."
+    }
+  },
+  "required": ["name"]
+}

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

@@ -0,0 +1,23 @@
+import type { Tree } from '@nx/devkit';
+import type { LibraryGeneratorSchema } from './schema.d';
+/**
+ * Generates a publishable pip-native Python library: `pyproject.toml` +
+ * `project.json` (lint/test/build/`nx-release-publish`) + a sample module
+ * and pytest.
+ *
+ * @remarks
+ * `nx-release-publish` runs `python -m twine upload` (the `publish`
+ * executor); the project's own `release.version.versionActions` points at
+ * this package's hand-written `PythonVersionActions` implementation, so
+ * `nx release` reads/writes `pyproject.toml` correctly regardless of
+ * whatever default the consuming workspace's `nx.json` configures (npm's
+ * default, typically).
+ *
+ * @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 libraryGenerator(tree: Tree, options: LibraryGeneratorSchema): Promise<void>;
+//# sourceMappingURL=generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../src/generators/library/generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEtC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAExD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAA8B,gBAAgB,CAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ1G"}

package/dist/generators/library/generator.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = libraryGenerator;
+const generateProject_1 = require("../../internal/generateProject");
+/**
+ * Generates a publishable pip-native Python library: `pyproject.toml` +
+ * `project.json` (lint/test/build/`nx-release-publish`) + a sample module
+ * and pytest.
+ *
+ * @remarks
+ * `nx-release-publish` runs `python -m twine upload` (the `publish`
+ * executor); the project's own `release.version.versionActions` points at
+ * this package's hand-written `PythonVersionActions` implementation, so
+ * `nx release` reads/writes `pyproject.toml` correctly regardless of
+ * whatever default the consuming workspace's `nx.json` configures (npm's
+ * default, typically).
+ *
+ * @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 libraryGenerator(tree, options) {
+    (0, generateProject_1.generateBuildableProject)(tree, {
+        name: options.name,
+        directory: options.directory ?? `libs/${options.name}`,
+        projectType: 'library',
+        publishable: true,
+    });
+    await (0, generateProject_1.formatFiles)(tree);
+}
+//# sourceMappingURL=generator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../src/generators/library/generator.ts"],"names":[],"mappings":";;;AACA,oEAAsF;AAGtF;;;;;;;;;;;;;;;;;;GAkBG;AACY,KAAK,2BAA4B,IAAU,EAAE,OAA+B;IACzF,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,SAAS;QACtB,WAAW,EAAE,IAAI;KAClB,CAAC,CAAA;IACF,MAAM,IAAA,6BAAW,EAAC,IAAI,CAAC,CAAA;AACzB,CAAC"}

package/dist/generators/library/schema.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "MnciNxPythonPipLibrary",
+  "title": "Create a publishable Python library",
+  "description": "Hand-authors a pip-native, publishable Python library: pyproject.toml (hatchling) + project.json (lint/test/build/nx-release-publish targets, a project-level versionActions override) + 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 libs/<name>)."
+    }
+  },
+  "required": ["name"]
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAA"}

package/dist/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/internal/azureFunctionApp.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The Azure Functions v2 entry written into a generated Python function app.
+ *
+ * @remarks
+ * The Python v2 programming model: a module-level `func.FunctionApp()` with
+ * decorated routes. The handler is thin — the testable logic lives in the
+ * module's `greeting.py` (imported here), so pytest needs no `azure-functions`
+ * install. Anonymous auth keeps the sample runnable locally with `func start`.
+ *
+ * @param moduleDirectory - The app's Python module directory (import root).
+ * @returns The `function_app.py` contents.
+ * @throws Never - pure string build.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function pythonFunctionAppMain(moduleDirectory: string): string;
+/**
+ * The `host.json` written into a generated Python function app.
+ *
+ * @remarks
+ * The v4 extension bundle is what the Functions host uses to resolve bindings;
+ * `version: 2.0` is the runtime schema. Deliberately minimal.
+ */
+export declare const PYTHON_FUNCTION_APP_HOST_JSON = "{\n  \"version\": \"2.0\",\n  \"extensionBundle\": {\n    \"id\": \"Microsoft.Azure.Functions.ExtensionBundle\",\n    \"version\": \"[4.*, 5.0.0)\"\n  }\n}\n";
+/**
+ * The `requirements.txt` written into a generated Python function app.
+ *
+ * @remarks
+ * Azure's Python worker installs these at deploy time (Oryx build). Only the
+ * SDK is needed for the sample; app deps are added here as the app grows.
+ */
+export declare const PYTHON_FUNCTION_APP_REQUIREMENTS = "azure-functions\n";
+/**
+ * A sample pure helper written into a Python function app's module.
+ *
+ * @remarks
+ * Gives the app a genuinely testable unit (the HTTP handler would need the
+ * Functions runtime), so pytest has a real passing test out of the box.
+ */
+export declare const PYTHON_FUNCTION_APP_GREETING = "def build_greeting(name: str) -> str:\n    \"\"\"Build the greeting returned by the sample HTTP function.\"\"\"\n    return \"Hello, \" + name + \"!\"\n";
+/**
+ * The sample pytest proving the Python function app's test target runs.
+ *
+ * @remarks
+ * Imports only the pure helper (no `azure-functions`), so it passes with
+ * plain `pytest` — no install step needed.
+ *
+ * @param moduleDirectory - The app's Python module directory (import root).
+ * @returns The `tests/test_greeting.py` contents.
+ * @throws Never - pure string build.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function pythonFunctionAppGreetingTest(moduleDirectory: string): string;
+//# sourceMappingURL=azureFunctionApp.d.ts.map

package/dist/internal/azureFunctionApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"azureFunctionApp.d.ts","sourceRoot":"","sources":["../../src/internal/azureFunctionApp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAatE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,kKAOzC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC,sBAC5C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,6JAGxC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,CAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAO9E"}

package/dist/internal/azureFunctionApp.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PYTHON_FUNCTION_APP_GREETING = exports.PYTHON_FUNCTION_APP_REQUIREMENTS = exports.PYTHON_FUNCTION_APP_HOST_JSON = void 0;
+exports.pythonFunctionAppMain = pythonFunctionAppMain;
+exports.pythonFunctionAppGreetingTest = pythonFunctionAppGreetingTest;
+/**
+ * The Azure Functions v2 entry written into a generated Python function app.
+ *
+ * @remarks
+ * The Python v2 programming model: a module-level `func.FunctionApp()` with
+ * decorated routes. The handler is thin — the testable logic lives in the
+ * module's `greeting.py` (imported here), so pytest needs no `azure-functions`
+ * install. Anonymous auth keeps the sample runnable locally with `func start`.
+ *
+ * @param moduleDirectory - The app's Python module directory (import root).
+ * @returns The `function_app.py` contents.
+ * @throws Never - pure string build.
+ * @typeParam None - this function has no generic type parameters.
+ */
+function pythonFunctionAppMain(moduleDirectory) {
+    return `import azure.functions as func
+
+from ${moduleDirectory}.greeting import build_greeting
+
+app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)
+
+
+@app.route(route="hello")
+def hello(req: func.HttpRequest) -> func.HttpResponse:
+    name = req.params.get("name", "world")
+    return func.HttpResponse(build_greeting(name))
+`;
+}
+/**
+ * The `host.json` written into a generated Python function app.
+ *
+ * @remarks
+ * The v4 extension bundle is what the Functions host uses to resolve bindings;
+ * `version: 2.0` is the runtime schema. Deliberately minimal.
+ */
+exports.PYTHON_FUNCTION_APP_HOST_JSON = `{
+  "version": "2.0",
+  "extensionBundle": {
+    "id": "Microsoft.Azure.Functions.ExtensionBundle",
+    "version": "[4.*, 5.0.0)"
+  }
+}
+`;
+/**
+ * The `requirements.txt` written into a generated Python function app.
+ *
+ * @remarks
+ * Azure's Python worker installs these at deploy time (Oryx build). Only the
+ * SDK is needed for the sample; app deps are added here as the app grows.
+ */
+exports.PYTHON_FUNCTION_APP_REQUIREMENTS = `azure-functions
+`;
+/**
+ * A sample pure helper written into a Python function app's module.
+ *
+ * @remarks
+ * Gives the app a genuinely testable unit (the HTTP handler would need the
+ * Functions runtime), so pytest has a real passing test out of the box.
+ */
+exports.PYTHON_FUNCTION_APP_GREETING = `def build_greeting(name: str) -> str:
+    """Build the greeting returned by the sample HTTP function."""
+    return "Hello, " + name + "!"
+`;
+/**
+ * The sample pytest proving the Python function app's test target runs.
+ *
+ * @remarks
+ * Imports only the pure helper (no `azure-functions`), so it passes with
+ * plain `pytest` — no install step needed.
+ *
+ * @param moduleDirectory - The app's Python module directory (import root).
+ * @returns The `tests/test_greeting.py` contents.
+ * @throws Never - pure string build.
+ * @typeParam None - this function has no generic type parameters.
+ */
+function pythonFunctionAppGreetingTest(moduleDirectory) {
+    return `from ${moduleDirectory}.greeting import build_greeting
+
+
+def test_build_greeting() -> None:
+    assert build_greeting("world") == "Hello, world!"
+`;
+}
+//# sourceMappingURL=azureFunctionApp.js.map

package/dist/internal/azureFunctionApp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"azureFunctionApp.js","sourceRoot":"","sources":["../../src/internal/azureFunctionApp.ts"],"names":[],"mappings":";;;;;AAAA;;;;;;;;;;;;;GAaG;AACH,+BAAuC,eAAuB;IAC5D,OAAO;;OAEF,eAAe;;;;;;;;;CASrB,CAAA;AACD,CAAC;AAED;;;;;;GAMG;AACU,QAAA,6BAA6B,GAAG;;;;;;;CAO5C,CAAA;AAED;;;;;;GAMG;AACU,QAAA,gCAAgC,GAAG;CAC/C,CAAA;AAED;;;;;;GAMG;AACU,QAAA,4BAA4B,GAAG;;;CAG3C,CAAA;AAED;;;;;;;;;;;GAWG;AACH,uCAA+C,eAAuB;IACpE,OAAO,QAAQ,eAAe;;;;;CAK/B,CAAA;AACD,CAAC"}

package/dist/internal/executorContext.d.ts

@@ -0,0 +1,17 @@
+import type { ExecutorContext } from '@nx/devkit';
+/**
+ * Resolves the running project's workspace-relative root directory from an
+ * executor context.
+ *
+ * @remarks
+ * Shared by every executor in this package, so each one gets the project
+ * root (to build the `cwd` it runs pip/pytest/ruff/twine in) the same way.
+ *
+ * @param context - The Nx executor context.
+ * @returns The workspace-relative project root.
+ * @throws Error when the context has no resolvable project (should be
+ * unreachable — Nx always sets `projectName` for a target invocation).
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function projectRootFrom(context: ExecutorContext): string;
+//# sourceMappingURL=executorContext.d.ts.map

package/dist/internal/executorContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executorContext.d.ts","sourceRoot":"","sources":["../../src/internal/executorContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAE,OAAO,EAAE,eAAe,GAAG,MAAM,CAOjE"}

package/dist/internal/executorContext.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectRootFrom = projectRootFrom;
+/**
+ * Resolves the running project's workspace-relative root directory from an
+ * executor context.
+ *
+ * @remarks
+ * Shared by every executor in this package, so each one gets the project
+ * root (to build the `cwd` it runs pip/pytest/ruff/twine in) the same way.
+ *
+ * @param context - The Nx executor context.
+ * @returns The workspace-relative project root.
+ * @throws Error when the context has no resolvable project (should be
+ * unreachable — Nx always sets `projectName` for a target invocation).
+ * @typeParam None - this function has no generic type parameters.
+ */
+function projectRootFrom(context) {
+    const projectName = context.projectName;
+    const root = projectName ? context.projectsConfigurations?.projects[projectName]?.root : undefined;
+    if (!root) {
+        throw new Error('Could not resolve the project root from the executor context.');
+    }
+    return root;
+}
+//# sourceMappingURL=executorContext.js.map

package/dist/internal/executorContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executorContext.js","sourceRoot":"","sources":["../../src/internal/executorContext.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;GAaG;AACH,yBAAiC,OAAwB;IACvD,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAA;IACvC,MAAM,IAAI,GAAG,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,SAAS,CAAA;IAClG,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAA;IAClF,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/internal/generateProject.d.ts

@@ -0,0 +1,43 @@
+import { type Tree } from '@nx/devkit';
+/**
+ * Options shared by every buildable-project generator (`application`, `library`).
+ *
+ * @remarks
+ * `publishable` is the only thing that differs between the `application` and
+ * `library` generators — see {@link generateBuildableProject}.
+ *
+ * @typeParam None - this interface has no generic type parameters.
+ */
+export interface BuildableProjectOptions {
+    /** The project name. */
+    name: string;
+    /** Workspace-relative directory. */
+    directory: string;
+    /** `application` (apps) or `library` (libs/python-packages). */
+    projectType: 'application' | 'library';
+    /** Adds a `nx-release-publish` target + a project-level `versionActions` override. */
+    publishable?: boolean;
+}
+/**
+ * Writes a buildable Python project: `pyproject.toml` + `project.json`
+ * (lint/test/build[/publish]) + a sample module and pytest.
+ *
+ * @remarks
+ * Shared by the `application` and `library` generators — the only difference
+ * between an app and a publishable lib is whether `publishable` adds the
+ * `nx-release-publish` target and the project-level
+ * `release.version.versionActions` override pointing at this package's own
+ * hand-written `PythonVersionActions` implementation
+ * (`@mnci/nx-python-pip/release/version-actions`), which wins over any
+ * workspace-level default for just this project — the same mechanism
+ * `@nxlv/python`'s own `--publishable` flag used.
+ *
+ * @param tree - The Nx virtual file system.
+ * @param options - The project name, directory, type and publishability.
+ * @returns Nothing.
+ * @throws Never - pure Tree writes.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function generateBuildableProject(tree: Tree, options: BuildableProjectOptions): void;
+export { formatFiles } from '@nx/devkit';
+//# sourceMappingURL=generateProject.d.ts.map

package/dist/internal/generateProject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateProject.d.ts","sourceRoot":"","sources":["../../src/internal/generateProject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsD,KAAK,IAAI,EAAE,MAAM,YAAY,CAAA;AAU1F;;;;;;;;GAQG;AACH,MAAM,WAAW,uBAAuB;IACtC,wBAAwB;IACxB,IAAI,EAAU,MAAM,CAAA;IACpB,oCAAoC;IACpC,SAAS,EAAK,MAAM,CAAA;IACpB,gEAAgE;IAChE,WAAW,EAAG,aAAa,GAAG,SAAS,CAAA;IACvC,sFAAsF;IACtF,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,uBAAuB,GAAG,IAAI,CA2B5F;AAED,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA"}

package/dist/internal/generateProject.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFiles = void 0;
+exports.generateBuildableProject = generateBuildableProject;
+const devkit_1 = require("@nx/devkit");
+const pythonProject_1 = require("./pythonProject");
+/** The `nx-release-publish` target for a publishable Python library (twine). */
+const PUBLISH_TARGET = {
+    executor: '@mnci/nx-python-pip:publish',
+    dependsOn: ['build'],
+    options: {},
+};
+/**
+ * Writes a buildable Python project: `pyproject.toml` + `project.json`
+ * (lint/test/build[/publish]) + a sample module and pytest.
+ *
+ * @remarks
+ * Shared by the `application` and `library` generators — the only difference
+ * between an app and a publishable lib is whether `publishable` adds the
+ * `nx-release-publish` target and the project-level
+ * `release.version.versionActions` override pointing at this package's own
+ * hand-written `PythonVersionActions` implementation
+ * (`@mnci/nx-python-pip/release/version-actions`), which wins over any
+ * workspace-level default for just this project — the same mechanism
+ * `@nxlv/python`'s own `--publishable` flag used.
+ *
+ * @param tree - The Nx virtual file system.
+ * @param options - The project name, directory, type and publishability.
+ * @returns Nothing.
+ * @throws Never - pure Tree writes.
+ * @typeParam None - this function has no generic type parameters.
+ */
+function generateBuildableProject(tree, options) {
+    const moduleDirectory = (0, pythonProject_1.pythonModuleDirectory)(options.name);
+    const root = options.directory;
+    const targets = {
+        lint: { executor: '@mnci/nx-python-pip:lint', options: {} },
+        test: { executor: '@mnci/nx-python-pip:test', options: {} },
+        build: { executor: '@mnci/nx-python-pip:build', outputs: ['{projectRoot}/dist'], options: {} },
+    };
+    const project = {
+        root,
+        projectType: options.projectType,
+        sourceRoot: root,
+        targets,
+    };
+    if (options.publishable) {
+        targets['nx-release-publish'] = PUBLISH_TARGET;
+        project.release = { version: { versionActions: '@mnci/nx-python-pip/release/version-actions' } };
+    }
+    (0, devkit_1.addProjectConfiguration)(tree, options.name, project);
+    tree.write(`${root}/pyproject.toml`, (0, pythonProject_1.pythonPyprojectToml)(options.name, moduleDirectory));
+    tree.write(`${root}/${moduleDirectory}/__init__.py`, (0, pythonProject_1.pythonSampleModule)(moduleDirectory));
+    tree.write(`${root}/tests/test_${moduleDirectory}.py`, (0, pythonProject_1.pythonSampleTest)(moduleDirectory));
+}
+var devkit_2 = require("@nx/devkit");
+Object.defineProperty(exports, "formatFiles", { enumerable: true, get: function () { return devkit_2.formatFiles; } });
+//# sourceMappingURL=generateProject.js.map

package/dist/internal/generateProject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateProject.js","sourceRoot":"","sources":["../../src/internal/generateProject.ts"],"names":[],"mappings":";;;;AAAA,uCAA0F;AAC1F,mDAAkH;AAElH,gFAAgF;AAChF,MAAM,cAAc,GAAG;IACrB,QAAQ,EAAG,6BAA6B;IACxC,SAAS,EAAE,CAAC,OAAO,CAAC;IACpB,OAAO,EAAI,EAAE;CACd,CAAA;AAsBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,kCAA0C,IAAU,EAAE,OAAgC;IACpF,MAAM,eAAe,GAAG,IAAA,qCAAqB,EAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3D,MAAM,IAAI,GAAG,OAAO,CAAC,SAAS,CAAA;IAE9B,MAAM,OAAO,GAAoC;QAC/C,IAAI,EAAG,EAAE,QAAQ,EAAE,0BAA0B,EAAE,OAAO,EAAE,EAAE,EAAE;QAC5D,IAAI,EAAG,EAAE,QAAQ,EAAE,0BAA0B,EAAE,OAAO,EAAE,EAAE,EAAE;QAC5D,KAAK,EAAE,EAAE,QAAQ,EAAE,2BAA2B,EAAE,OAAO,EAAE,CAAC,oBAAoB,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;KAC/F,CAAA;IAED,MAAM,OAAO,GAAyB;QACpC,IAAI;QACJ,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,UAAU,EAAG,IAAI;QACjB,OAAO;KACR,CAAA;IAED,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;QACxB,OAAO,CAAC,oBAAoB,CAAC,GAAG,cAAc,CAAA;QAC9C,OAAO,CAAC,OAAO,GAAG,EAAE,OAAO,EAAE,EAAE,cAAc,EAAE,6CAA6C,EAAE,EAAE,CAAA;IAClG,CAAC;IAED,IAAA,gCAAuB,EAAC,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;IAEpD,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,iBAAiB,EAAE,IAAA,mCAAmB,EAAC,OAAO,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC,CAAA;IACxF,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI,eAAe,cAAc,EAAE,IAAA,kCAAkB,EAAC,eAAe,CAAC,CAAC,CAAA;IACzF,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,eAAe,eAAe,KAAK,EAAE,IAAA,gCAAgB,EAAC,eAAe,CAAC,CAAC,CAAA;AAC3F,CAAC;AAED,qCAAwC;AAA/B,qGAAA,WAAW,OAAA"}

package/dist/internal/pythonProject.d.ts

@@ -0,0 +1,57 @@
+/**
+ * A Python project's module directory name, derived from its Nx project name.
+ *
+ * @remarks
+ * Python identifiers cannot contain hyphens, so `my-svc` becomes `my_svc`.
+ *
+ * @param name - The Nx project name.
+ * @returns The module directory's basename (e.g. `my_svc`).
+ * @throws Never - pure string mapping.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function pythonModuleDirectory(name: string): string;
+/**
+ * The `pyproject.toml` written for a buildable Python project (app or lib).
+ *
+ * @remarks
+ * `hatchling` is the PEP 517 backend. The wheel target's `packages` list is
+ * explicit (not hatchling's own auto-detection) because the `build` executor
+ * patches this exact list when vendoring an internal-lib's module into the
+ * wheel (see `parseVendorEntries`). `dependencies` starts empty — external
+ * and vendored dependencies alike are wired by hand after generation; no
+ * generator wires cross-project Python dependencies automatically.
+ *
+ * @param name - The project name.
+ * @param moduleDirectory - The project's module directory basename.
+ * @returns The `pyproject.toml` contents.
+ * @throws Never - pure string build.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function pythonPyprojectToml(name: string, moduleDirectory: string): string;
+/**
+ * A sample pure function written into a generated Python project's module.
+ *
+ * @remarks
+ * Gives every generated project a genuinely testable unit out of the box —
+ * paired with {@link pythonSampleTest}.
+ *
+ * @param moduleDirectory - The project's module directory basename.
+ * @returns The `<module>/__init__.py` contents.
+ * @throws Never - pure string build.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function pythonSampleModule(moduleDirectory: string): string;
+/**
+ * The sample pytest proving a generated Python project's `test` target runs.
+ *
+ * @remarks
+ * Imports {@link pythonSampleModule}'s function, so a fresh project's `test`
+ * target is green out of the box, no wiring needed.
+ *
+ * @param moduleDirectory - The project's module directory basename.
+ * @returns The `tests/test_<module>.py` contents.
+ * @throws Never - pure string build.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function pythonSampleTest(moduleDirectory: string): string;
+//# sourceMappingURL=pythonProject.d.ts.map