projen 0.0.0

package/lib/python/poetry.js

@@ -0,0 +1,169 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoetryPyproject = exports.Poetry = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const component_1 = require("../component");
+const dependencies_1 = require("../dependencies");
+const task_runtime_1 = require("../task-runtime");
+const toml_1 = require("../toml");
+const util_1 = require("../util");
+/**
+ * (experimental) Manage project dependencies, virtual environments, and packaging through the poetry CLI tool.
+ *
+ * @experimental
+ */
+class Poetry extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options) {
+        var _c;
+        super(project);
+        this.installTask = project.addTask('install', {
+            description: 'Install and upgrade dependencies',
+            exec: 'poetry update',
+        });
+        this.project.tasks.addEnvironment('VIRTUAL_ENV', '$(poetry env info -p)');
+        this.project.tasks.addEnvironment('PATH', '$(echo $(poetry env info -p)/bin:$PATH)');
+        project.packageTask.exec('poetry build');
+        this.publishTestTask = project.addTask('publish:test', {
+            description: 'Uploads the package against a test PyPI endpoint.',
+            exec: 'poetry publish -r testpypi',
+        });
+        this.publishTask = project.addTask('publish', {
+            description: 'Uploads the package to PyPI.',
+            exec: 'poetry publish',
+        });
+        new PoetryPyproject(project, {
+            name: project.name,
+            version: options.version,
+            description: (_c = options.description) !== null && _c !== void 0 ? _c : '',
+            license: options.license,
+            authors: [`${options.authorName} <${options.authorEmail}>`],
+            homepage: options.homepage,
+            classifiers: options.classifiers,
+            ...options.poetryOptions,
+            dependencies: () => this.synthDependencies(),
+            devDependencies: () => this.synthDevDependencies(),
+        });
+        new toml_1.TomlFile(project, 'poetry.toml', {
+            committed: false,
+            obj: {
+                repositories: {
+                    testpypi: {
+                        url: 'https://test.pypi.org/legacy/',
+                    },
+                },
+            },
+        });
+    }
+    synthDependencies() {
+        const dependencies = {};
+        let pythonDefined = false;
+        for (const pkg of this.project.deps.all) {
+            if (pkg.name === 'python') {
+                pythonDefined = true;
+            }
+            if (pkg.type === dependencies_1.DependencyType.RUNTIME) {
+                dependencies[pkg.name] = pkg.version;
+            }
+        }
+        if (!pythonDefined) {
+            // Python version must be defined for poetry projects. Default to ^3.6.
+            dependencies.python = '^3.6';
+        }
+        return dependencies;
+    }
+    synthDevDependencies() {
+        const dependencies = {};
+        for (const pkg of this.project.deps.all) {
+            if ([dependencies_1.DependencyType.DEVENV].includes(pkg.type)) {
+                dependencies[pkg.name] = pkg.version;
+            }
+        }
+        return dependencies;
+    }
+    /**
+     * (experimental) Adds a runtime dependency.
+     *
+     * @param spec Format `<module>@<semver>`.
+     * @experimental
+     */
+    addDependency(spec) {
+        this.project.deps.addDependency(spec, dependencies_1.DependencyType.RUNTIME);
+    }
+    /**
+     * (experimental) Adds a dev dependency.
+     *
+     * @param spec Format `<module>@<semver>`.
+     * @experimental
+     */
+    addDevDependency(spec) {
+        this.project.deps.addDependency(spec, dependencies_1.DependencyType.DEVENV);
+    }
+    /**
+     * (experimental) Initializes the virtual environment if it doesn't exist (called during post-synthesis).
+     *
+     * @experimental
+     */
+    setupEnvironment() {
+        const result = util_1.execOrUndefined('which poetry', { cwd: this.project.outdir });
+        if (!result) {
+            this.project.logger.info('Unable to setup an environment since poetry is not installed. Please install poetry (https://python-poetry.org/docs/) or use a different component for managing environments such as \'venv\'.');
+        }
+        let envPath = util_1.execOrUndefined('poetry env info -p', { cwd: this.project.outdir });
+        if (!envPath) {
+            this.project.logger.info('Setting up a virtual environment...');
+            util_1.exec('poetry env use python', { cwd: this.project.outdir });
+            envPath = util_1.execOrUndefined('poetry env info -p', { cwd: this.project.outdir });
+            this.project.logger.info(`Environment successfully created (located in ${envPath}}).`);
+        }
+    }
+    /**
+     * (experimental) Installs dependencies (called during post-synthesis).
+     *
+     * @experimental
+     */
+    installDependencies() {
+        this.project.logger.info('Installing dependencies...');
+        const runtime = new task_runtime_1.TaskRuntime(this.project.outdir);
+        runtime.runTask(this.installTask.name);
+    }
+}
+exports.Poetry = Poetry;
+_a = JSII_RTTI_SYMBOL_1;
+Poetry[_a] = { fqn: "projen.python.Poetry", version: "0.46.8" };
+/**
+ * (experimental) Represents configuration of a pyproject.toml file for a Poetry project.
+ *
+ * @see https://python-poetry.org/docs/pyproject/
+ * @experimental
+ */
+class PoetryPyproject extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options) {
+        super(project);
+        const decamelisedOptions = util_1.decamelizeKeysRecursively(options, { separator: '-' });
+        this.file = new toml_1.TomlFile(project, 'pyproject.toml', {
+            omitEmpty: false,
+            obj: {
+                'build-system': {
+                    'requires': ['poetry_core>=1.0.0'],
+                    'build-backend': 'poetry.core.masonry.api',
+                },
+                'tool': {
+                    poetry: {
+                        ...decamelisedOptions,
+                    },
+                },
+            },
+        });
+    }
+}
+exports.PoetryPyproject = PoetryPyproject;
+_b = JSII_RTTI_SYMBOL_1;
+PoetryPyproject[_b] = { fqn: "projen.python.PoetryPyproject", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"poetry.js","sourceRoot":"","sources":["../../src/python/poetry.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component } from '../component';\nimport { DependencyType } from '../dependencies';\nimport { Task } from '../task';\nimport { TaskRuntime } from '../task-runtime';\nimport { TomlFile } from '../toml';\nimport { decamelizeKeysRecursively, exec, execOrUndefined } from '../util';\nimport { IPythonDeps } from './python-deps';\nimport { IPythonEnv } from './python-env';\nimport { IPythonPackaging, PythonPackagingOptions } from './python-packaging';\nimport { PythonProject } from './python-project';\n\n                                                                                                           \nexport class Poetry extends Component implements IPythonDeps, IPythonEnv, IPythonPackaging {\n  public readonly installTask: Task;\n  public readonly publishTask: Task;\n\n                                                                             \n  public readonly publishTestTask: Task;\n\n  constructor(project: PythonProject, options: PythonPackagingOptions) {\n    super(project);\n\n    this.installTask = project.addTask('install', {\n      description: 'Install and upgrade dependencies',\n      exec: 'poetry update',\n    });\n\n    this.project.tasks.addEnvironment('VIRTUAL_ENV', '$(poetry env info -p)');\n    this.project.tasks.addEnvironment('PATH', '$(echo $(poetry env info -p)/bin:$PATH)');\n\n    project.packageTask.exec('poetry build');\n\n    this.publishTestTask = project.addTask('publish:test', {\n      description: 'Uploads the package against a test PyPI endpoint.',\n      exec: 'poetry publish -r testpypi',\n    });\n\n    this.publishTask = project.addTask('publish', {\n      description: 'Uploads the package to PyPI.',\n      exec: 'poetry publish',\n    });\n\n    new PoetryPyproject(project, {\n      name: project.name,\n      version: options.version,\n      description: options.description ?? '',\n      license: options.license,\n      authors: [`${options.authorName} <${options.authorEmail}>`],\n      homepage: options.homepage,\n      classifiers: options.classifiers,\n      ...options.poetryOptions,\n      dependencies: () => this.synthDependencies(),\n      devDependencies: () => this.synthDevDependencies(),\n    });\n\n    new TomlFile(project, 'poetry.toml', {\n      committed: false,\n      obj: {\n        repositories: {\n          testpypi: {\n            url: 'https://test.pypi.org/legacy/',\n          },\n        },\n      },\n    });\n  }\n\n  private synthDependencies() {\n    const dependencies: { [key: string]: any } = {};\n    let pythonDefined: boolean = false;\n    for (const pkg of this.project.deps.all) {\n      if (pkg.name === 'python') {\n        pythonDefined = true;\n      }\n      if (pkg.type === DependencyType.RUNTIME) {\n        dependencies[pkg.name] = pkg.version;\n      }\n    }\n    if (!pythonDefined) {\n      // Python version must be defined for poetry projects. Default to ^3.6.\n      dependencies.python = '^3.6';\n    }\n    return dependencies;\n  }\n\n  private synthDevDependencies() {\n    const dependencies: { [key: string]: any } = {};\n    for (const pkg of this.project.deps.all) {\n      if ([DependencyType.DEVENV].includes(pkg.type)) {\n        dependencies[pkg.name] = pkg.version;\n      }\n    }\n    return dependencies;\n  }\n\n                                                                                            \n  public addDependency(spec: string) {\n    this.project.deps.addDependency(spec, DependencyType.RUNTIME);\n  }\n\n                                                                                        \n  public addDevDependency(spec: string) {\n    this.project.deps.addDependency(spec, DependencyType.DEVENV);\n  }\n\n                                                                                                        \n  public setupEnvironment() {\n    const result = execOrUndefined('which poetry', { cwd: this.project.outdir });\n    if (!result) {\n      this.project.logger.info('Unable to setup an environment since poetry is not installed. Please install poetry (https://python-poetry.org/docs/) or use a different component for managing environments such as \\'venv\\'.');\n    }\n\n    let envPath = execOrUndefined('poetry env info -p', { cwd: this.project.outdir });\n    if (!envPath) {\n      this.project.logger.info('Setting up a virtual environment...');\n      exec('poetry env use python', { cwd: this.project.outdir });\n      envPath = execOrUndefined('poetry env info -p', { cwd: this.project.outdir });\n      this.project.logger.info(`Environment successfully created (located in ${envPath}}).`);\n    }\n  }\n\n                                                                      \n  public installDependencies() {\n    this.project.logger.info('Installing dependencies...');\n    const runtime = new TaskRuntime(this.project.outdir);\n    runtime.runTask(this.installTask.name);\n  }\n}\n\n                                                                                     \nexport interface PoetryPyprojectOptionsWithoutDeps {\n                                                \n  readonly name?: string;\n\n                                                   \n  readonly version?: string;\n\n                                                               \n  readonly description?: string;\n\n                                                                                                                                                                                          \n  readonly license?: string;\n\n                                                                               \n  readonly authors?: string[];\n\n                                                                                   \n  readonly maintainers?: string[];\n\n                                                            \n  readonly readme?: string;\n\n                                                     \n  readonly homepage?: string;\n\n                                                        \n  readonly repository?: string;\n\n                                                           \n  readonly documentation?: string;\n\n                                                                            \n  readonly keywords?: string[];\n\n                                                                                                                         \n  readonly classifiers?: string[];\n\n                                                                                     \n  readonly packages?: any[];\n\n                                                                               \n  readonly include?: string[];\n\n                                                                                                                                                                                                                                     \n  readonly exclude?: string[];\n\n                                                                                               \n  readonly scripts?: { [key: string]: any };\n\n                                                                     \n  readonly source?: any[];\n\n                               \n  readonly extras?: { [key: string]: string[] };\n\n                                                                                                 \n  readonly plugins?: any;\n\n                                                                                                                    \n  readonly urls?: { [key: string]: string };\n}\n\n                                                                                     \nexport interface PoetryPyprojectOptions extends PoetryPyprojectOptionsWithoutDeps {\n                                                                                                                                                                                       \n  readonly dependencies?: { [key: string]: any };\n\n                                                                                                               \n  readonly devDependencies?: { [key: string]: any };\n}\n\n                                                                                                                                       \nexport class PoetryPyproject extends Component {\n  public readonly file: TomlFile;\n\n  constructor(project: PythonProject, options: PoetryPyprojectOptions) {\n    super(project);\n\n    const decamelisedOptions = decamelizeKeysRecursively(options, { separator: '-' });\n\n    this.file = new TomlFile(project, 'pyproject.toml', {\n      omitEmpty: false,\n      obj: {\n        'build-system': {\n          'requires': ['poetry_core>=1.0.0'],\n          'build-backend': 'poetry.core.masonry.api',\n        },\n        'tool': {\n          poetry: {\n            ...decamelisedOptions,\n          },\n        },\n      },\n    });\n  }\n}\n"]}

package/lib/python/projenrc.d.ts

@@ -0,0 +1,42 @@
+import { Component } from '../component';
+import { Project } from '../project';
+/**
+ * (experimental) Options for `Projenrc`.
+ *
+ * @experimental
+ */
+export interface ProjenrcOptions {
+    /**
+     * (experimental) The name of the projenrc file.
+     *
+     * @default ".projenrc.py"
+     * @experimental
+     */
+    readonly filename?: string;
+    /**
+     * (experimental) The projen version to use.
+     *
+     * @default - current version
+     * @experimental
+     */
+    readonly projenVersion?: string;
+}
+/**
+ * (experimental) Allows writing projenrc files in python.
+ *
+ * This will install `projen` as a Python dependency and will add a
+ * `synth` task which will run `.projenrc.py`.
+ *
+ * @experimental
+ */
+export declare class Projenrc extends Component {
+    /**
+     * The name of the projenrc file.
+     */
+    private readonly rcfile;
+    /**
+     * @experimental
+     */
+    constructor(project: Project, options?: ProjenrcOptions);
+    private generateProjenrc;
+}

package/lib/python/projenrc.js

@@ -0,0 +1,135 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Projenrc = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path_1 = require("path");
+const case_1 = require("case");
+const fs_extra_1 = require("fs-extra");
+const common_1 = require("../common");
+const component_1 = require("../component");
+const dependencies_1 = require("../dependencies");
+const inventory_1 = require("../inventory");
+/**
+ * (experimental) Allows writing projenrc files in python.
+ *
+ * This will install `projen` as a Python dependency and will add a
+ * `synth` task which will run `.projenrc.py`.
+ *
+ * @experimental
+ */
+class Projenrc extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options = {}) {
+        var _b, _c;
+        super(project);
+        const projenVersion = (_b = options.projenVersion) !== null && _b !== void 0 ? _b : common_1.PROJEN_VERSION;
+        this.rcfile = (_c = options.filename) !== null && _c !== void 0 ? _c : '.projenrc.py';
+        project.deps.addDependency(`projen@${projenVersion}`, dependencies_1.DependencyType.DEVENV);
+        // set up the "default" task which is the task executed when `projen` is executed for this project.
+        project.defaultTask.exec('python .projenrc.py');
+        // if this is a new project, generate a skeleton for projenrc.py
+        this.generateProjenrc();
+    }
+    generateProjenrc() {
+        var _b, _c, _d;
+        const bootstrap = this.project.initProject;
+        if (!bootstrap) {
+            return;
+        }
+        const jsiiFqn = bootstrap.fqn;
+        const jsiiManifest = inventory_1.readJsiiManifest(jsiiFqn);
+        const jsiiType = jsiiManifest.types[jsiiFqn];
+        const optionsTypeFqn = (_d = (_c = (_b = jsiiType.initializer) === null || _b === void 0 ? void 0 : _b.parameters) === null || _c === void 0 ? void 0 : _c[0].type) === null || _d === void 0 ? void 0 : _d.fqn;
+        if (!optionsTypeFqn) {
+            this.project.logger.warn('cannot determine jsii type for project options');
+            return;
+        }
+        const pythonFile = path_1.join(this.project.outdir, this.rcfile);
+        // skip if file exists
+        if (fs_extra_1.existsSync(pythonFile)) {
+            return;
+        }
+        const lines = new Array();
+        let indent = 0;
+        const emit = (line = '') => lines.push(' '.repeat(indent * 4) + line);
+        // const openBlock = (line: string = '') => { emit(line + ' {'); indent++; };
+        // const closeBlock = () => { indent--; emit('}'); };
+        const optionFqns = {};
+        for (const option of bootstrap.type.options) {
+            if (option.fqn) {
+                optionFqns[option.name] = option.fqn;
+            }
+        }
+        const { renderedOptions, imports } = renderPythonOptions(indent, optionFqns, bootstrap.args);
+        emit(toPythonImport(jsiiFqn));
+        for (const fqn of imports) {
+            emit(toPythonImport(fqn));
+        }
+        emit();
+        emit(`project = ${jsiiType.name}(${renderedOptions})`);
+        emit();
+        emit('project.synth()');
+        fs_extra_1.mkdirpSync(path_1.dirname(pythonFile));
+        fs_extra_1.writeFileSync(pythonFile, lines.join('\n'));
+        this.project.logger.info(`Project definition file was created at ${pythonFile}`);
+    }
+}
+exports.Projenrc = Projenrc;
+_a = JSII_RTTI_SYMBOL_1;
+Projenrc[_a] = { fqn: "projen.python.Projenrc", version: "0.46.8" };
+function renderPythonOptions(indent, optionFqns, initOptions) {
+    const imports = new Set();
+    if (!initOptions || Object.keys(initOptions).length === 0) { // no options
+        return { renderedOptions: '', imports };
+    }
+    const lines = [''];
+    for (const [name, value] of Object.entries(initOptions)) {
+        const { pythonValue, importName } = toPythonValue(value, name, optionFqns);
+        if (importName)
+            imports.add(importName);
+        lines.push(`${toPythonProperty(name)}=${pythonValue},`);
+    }
+    const renderedOptions = lines.join(`\n${' '.repeat((indent + 1) * 4)}`).concat('\n');
+    return { renderedOptions, imports };
+}
+function toPythonProperty(prop) {
+    return case_1.snake(prop);
+}
+function toPythonValue(value, name, optionFqns) {
+    if (typeof value === 'boolean') {
+        return { pythonValue: value ? 'True' : 'False' };
+    }
+    else if (typeof value === 'number') {
+        return { pythonValue: JSON.stringify(value) };
+    }
+    else if (typeof value === 'string') {
+        if (optionFqns[name] !== undefined) {
+            const parts = optionFqns[name].split('.');
+            const base = parts[parts.length - 1];
+            const choice = String(value).toUpperCase().replace(/-/g, '_');
+            return { pythonValue: `${base}.${choice}`, importName: optionFqns[name] };
+        }
+        else {
+            return { pythonValue: JSON.stringify(value) };
+        }
+    }
+    else if (value === undefined || value === null) {
+        return { pythonValue: 'None' };
+    }
+    else {
+        return { pythonValue: JSON.stringify(value) };
+    }
+}
+function toPythonImport(fqn) {
+    const parts = fqn.split('.');
+    if (parts.length === 1) {
+        return `import ${parts[0]}`;
+    }
+    else {
+        return `from ${parts.slice(0, -1).join('.')} import ${parts[parts.length - 1]}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"projenrc.js","sourceRoot":"","sources":["../../src/python/projenrc.ts"],"names":[],"mappings":"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","sourcesContent":["import { dirname, join } from 'path';\nimport { snake } from 'case';\nimport { existsSync, mkdirpSync, writeFileSync } from 'fs-extra';\nimport { PROJEN_VERSION } from '../common';\nimport { Component } from '../component';\nimport { DependencyType } from '../dependencies';\nimport { readJsiiManifest } from '../inventory';\nimport { Project } from '../project';\n\n                                  \nexport interface ProjenrcOptions {\n                                                                            \n  readonly filename?: string;\n\n                                                                          \n  readonly projenVersion?: string;\n}\n\n                                                                                                                                                                         \nexport class Projenrc extends Component {\n  /**\n   * The name of the projenrc file.\n   */\n  private readonly rcfile: string;\n\n  constructor(project: Project, options: ProjenrcOptions = {}) {\n    super(project);\n\n    const projenVersion = options.projenVersion ?? PROJEN_VERSION;\n    this.rcfile = options.filename ?? '.projenrc.py';\n\n    project.deps.addDependency(`projen@${projenVersion}`, DependencyType.DEVENV);\n\n    // set up the \"default\" task which is the task executed when `projen` is executed for this project.\n    project.defaultTask.exec('python .projenrc.py');\n\n    // if this is a new project, generate a skeleton for projenrc.py\n    this.generateProjenrc();\n  }\n\n  private generateProjenrc() {\n    const bootstrap = this.project.initProject;\n    if (!bootstrap) {\n      return;\n    }\n    const jsiiFqn = bootstrap.fqn;\n    const jsiiManifest = readJsiiManifest(jsiiFqn);\n    const jsiiType = jsiiManifest.types[jsiiFqn];\n    const optionsTypeFqn = jsiiType.initializer?.parameters?.[0].type?.fqn;\n    if (!optionsTypeFqn) {\n      this.project.logger.warn('cannot determine jsii type for project options');\n      return;\n    }\n\n    const pythonFile = join(this.project.outdir, this.rcfile);\n\n    // skip if file exists\n    if (existsSync(pythonFile)) {\n      return;\n    }\n\n    const lines = new Array<string>();\n\n    let indent = 0;\n    const emit = (line: string = '') => lines.push(' '.repeat(indent * 4) + line);\n    // const openBlock = (line: string = '') => { emit(line + ' {'); indent++; };\n    // const closeBlock = () => { indent--; emit('}'); };\n\n    const optionFqns: Record<string, string> = {};\n    for (const option of bootstrap.type.options) {\n      if (option.fqn) {\n        optionFqns[option.name] = option.fqn;\n      }\n    }\n\n    const { renderedOptions, imports } = renderPythonOptions(indent, optionFqns, bootstrap.args);\n\n    emit(toPythonImport(jsiiFqn));\n    for (const fqn of imports) {\n      emit(toPythonImport(fqn));\n    }\n    emit();\n    emit(`project = ${jsiiType.name}(${renderedOptions})`);\n    emit();\n    emit('project.synth()');\n\n    mkdirpSync(dirname(pythonFile));\n    writeFileSync(pythonFile, lines.join('\\n'));\n\n    this.project.logger.info(`Project definition file was created at ${pythonFile}`);\n  }\n}\n\nfunction renderPythonOptions(indent: number, optionFqns: Record<string, string>, initOptions?: Record<string, any>) {\n  const imports = new Set<string>();\n  if (!initOptions || Object.keys(initOptions).length === 0) { // no options\n    return { renderedOptions: '', imports };\n  }\n\n  const lines = [''];\n\n  for (const [name, value] of Object.entries(initOptions)) {\n    const { pythonValue, importName } = toPythonValue(value, name, optionFqns);\n    if (importName) imports.add(importName);\n    lines.push(`${toPythonProperty(name)}=${pythonValue},`);\n  }\n\n  const renderedOptions = lines.join(`\\n${' '.repeat((indent + 1) * 4)}`).concat('\\n');\n  return { renderedOptions, imports };\n}\n\nfunction toPythonProperty(prop: string) {\n  return snake(prop);\n}\n\nfunction toPythonValue(value: any, name: string, optionFqns: Record<string, string>) {\n  if (typeof value === 'boolean') {\n    return { pythonValue: value ? 'True' : 'False' };\n  } else if (typeof value === 'number') {\n    return { pythonValue: JSON.stringify(value) };\n  } else if (typeof value === 'string') {\n    if (optionFqns[name] !== undefined) {\n      const parts = optionFqns[name].split('.');\n      const base = parts[parts.length - 1];\n      const choice = String(value).toUpperCase().replace(/-/g, '_');\n      return { pythonValue: `${base}.${choice}`, importName: optionFqns[name] };\n    } else {\n      return { pythonValue: JSON.stringify(value) };\n    }\n  } else if (value === undefined || value === null) {\n    return { pythonValue: 'None' };\n  } else {\n    return { pythonValue: JSON.stringify(value) };\n  }\n}\n\nfunction toPythonImport(fqn: string) {\n  const parts = fqn.split('.');\n  if (parts.length === 1) {\n    return `import ${parts[0]}`;\n  } else {\n    return `from ${parts.slice(0, -1).join('.')} import ${parts[parts.length - 1]}`;\n  }\n}\n"]}

package/lib/python/pytest.d.ts

@@ -0,0 +1,36 @@
+import { Component } from '../component';
+import { PythonProject } from './python-project';
+/**
+ * @experimental
+ */
+export interface PytestOptions {
+    /**
+     * (experimental) Pytest version.
+     *
+     * @default "6.2.1"
+     * @experimental
+     */
+    readonly version?: string;
+    /**
+     * (experimental) Directory with tests.
+     *
+     * @default 'tests'
+     * @experimental
+     */
+    readonly testdir?: string;
+    /**
+     * (experimental) Stop the testing process after the first N failures.
+     *
+     * @experimental
+     */
+    readonly maxFailures?: number;
+}
+/**
+ * @experimental
+ */
+export declare class Pytest extends Component {
+    /**
+     * @experimental
+     */
+    constructor(project: PythonProject, options?: PytestOptions);
+}

package/lib/python/pytest.js

@@ -0,0 +1,52 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pytest = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const component_1 = require("../component");
+const sample_file_1 = require("../sample-file");
+/**
+ * @experimental
+ */
+class Pytest extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options = {}) {
+        var _b;
+        super(project);
+        const version = (_b = options.version) !== null && _b !== void 0 ? _b : '6.2.1';
+        project.addDevDependency(`pytest@${version}`);
+        project.testTask.exec([
+            'pytest',
+            ...(options.maxFailures ? [`--maxfail=${options.maxFailures}`] : []),
+        ].join(' '));
+        new sample_file_1.SampleDir(project, 'tests', {
+            files: {
+                '__init__.py': '',
+                'test_example.py': [
+                    'import pytest',
+                    '',
+                    `from ${project.moduleName}.example import hello`,
+                    '',
+                    '@pytest.mark.parametrize(',
+                    '    ("name", "expected"),',
+                    '    [',
+                    '        ("A. Musing", "Hello A. Musing!"),',
+                    '        ("traveler", "Hello traveler!"),',
+                    '        ("projen developer", "Hello projen developer!"),',
+                    '    ],',
+                    ')',
+                    'def test_hello(name, expected):',
+                    '    """Example test with parametrization."""',
+                    '    assert hello(name) == expected',
+                    '',
+                ].join('\n'),
+            },
+        });
+    }
+}
+exports.Pytest = Pytest;
+_a = JSII_RTTI_SYMBOL_1;
+Pytest[_a] = { fqn: "projen.python.Pytest", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/python/python-deps.d.ts

@@ -0,0 +1,44 @@
+import { Dependency } from '../dependencies';
+import { Task } from '../task';
+/**
+ * @experimental
+ */
+export interface IPythonDeps {
+    /**
+     * (experimental) A task that installs and updates dependencies.
+     *
+     * @experimental
+     */
+    readonly installTask: Task;
+    /**
+     * (experimental) Adds a runtime dependency.
+     *
+     * @param spec Format `<module>@<semver>`.
+     * @experimental
+     */
+    addDependency(spec: string): void;
+    /**
+     * (experimental) Adds a dev dependency.
+     *
+     * @param spec Format `<module>@<semver>`.
+     * @experimental
+     */
+    addDevDependency(spec: string): void;
+    /**
+     * (experimental) Installs dependencies (called during post-synthesis).
+     *
+     * @experimental
+     */
+    installDependencies(): void;
+}
+/**
+ * @experimental
+ */
+export interface IPackageProvider {
+    /**
+     * (experimental) An array of packages (may be dynamically generated).
+     *
+     * @experimental
+     */
+    readonly packages: Dependency[];
+}

package/lib/python/python-deps.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHl0aG9uLWRlcHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHl0aG9uL3B5dGhvbi1kZXBzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEZXBlbmRlbmN5IH0gZnJvbSAnLi4vZGVwZW5kZW5jaWVzJztcbmltcG9ydCB7IFRhc2sgfSBmcm9tICcuLi90YXNrJztcblxuZXhwb3J0IGludGVyZmFjZSBJUHl0aG9uRGVwcyB7XG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcbiAgcmVhZG9ubHkgaW5zdGFsbFRhc2s6IFRhc2s7XG5cbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXG4gIGFkZERlcGVuZGVuY3koc3BlYzogc3RyaW5nKTogdm9pZDtcblxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFxuICBhZGREZXZEZXBlbmRlbmN5KHNwZWM6IHN0cmluZyk6IHZvaWQ7XG5cbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcbiAgaW5zdGFsbERlcGVuZGVuY2llcygpOiB2b2lkO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIElQYWNrYWdlUHJvdmlkZXIge1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXG4gIHJlYWRvbmx5IHBhY2thZ2VzOiBEZXBlbmRlbmN5W107XG59XG4iXX0=

package/lib/python/python-env.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @experimental
+ */
+export interface IPythonEnv {
+    /**
+     * (experimental) Initializes the virtual environment if it doesn't exist (called during post-synthesis).
+     *
+     * @experimental
+     */
+    setupEnvironment(): void;
+}

package/lib/python/python-env.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHl0aG9uLWVudi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9weXRob24vcHl0aG9uLWVudi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBJUHl0aG9uRW52IHtcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXG4gIHNldHVwRW52aXJvbm1lbnQoKTogdm9pZDtcbn1cbiJdfQ==

package/lib/python/python-packaging.d.ts

@@ -0,0 +1,80 @@
+import { Task } from '../task';
+import { PoetryPyprojectOptionsWithoutDeps } from './poetry';
+/**
+ * @experimental
+ */
+export interface IPythonPackaging {
+    /**
+     * (experimental) A task that uploads the package to a package repository.
+     *
+     * @experimental
+     */
+    readonly publishTask: Task;
+}
+/**
+ * @experimental
+ */
+export interface PythonPackagingOptions {
+    /**
+     * (experimental) Author's name.
+     *
+     * @default $GIT_USER_NAME
+     * @experimental
+     */
+    readonly authorName: string;
+    /**
+     * (experimental) Author's e-mail.
+     *
+     * @default $GIT_USER_EMAIL
+     * @experimental
+     */
+    readonly authorEmail: string;
+    /**
+     * (experimental) Version of the package.
+     *
+     * @default "0.1.0"
+     * @experimental
+     * @featured true
+     */
+    readonly version: string;
+    /**
+     * (experimental) A short description of the package.
+     *
+     * @experimental
+     * @featured true
+     */
+    readonly description?: string;
+    /**
+     * (experimental) License of this package as an SPDX identifier.
+     *
+     * @experimental
+     */
+    readonly license?: string;
+    /**
+     * (experimental) A URL to the website of the project.
+     *
+     * @experimental
+     */
+    readonly homepage?: string;
+    /**
+     * (experimental) A list of PyPI trove classifiers that describe the project.
+     *
+     * @see https://pypi.org/classifiers/
+     * @experimental
+     */
+    readonly classifiers?: string[];
+    /**
+     * (experimental) Additional fields to pass in the setup() function if using setuptools.
+     *
+     * @experimental
+     */
+    readonly setupConfig?: {
+        [key: string]: any;
+    };
+    /**
+     * (experimental) Additional options to set for poetry if using poetry.
+     *
+     * @experimental
+     */
+    readonly poetryOptions?: PoetryPyprojectOptionsWithoutDeps;
+}

package/lib/python/python-packaging.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHl0aG9uLXBhY2thZ2luZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9weXRob24vcHl0aG9uLXBhY2thZ2luZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVGFzayB9IGZyb20gJy4uL3Rhc2snO1xuaW1wb3J0IHsgUG9ldHJ5UHlwcm9qZWN0T3B0aW9uc1dpdGhvdXREZXBzIH0gZnJvbSAnLi9wb2V0cnknO1xuXG5leHBvcnQgaW50ZXJmYWNlIElQeXRob25QYWNrYWdpbmcge1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFxuICByZWFkb25seSBwdWJsaXNoVGFzazogVGFzaztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBQeXRob25QYWNrYWdpbmdPcHRpb25zIHtcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcbiAgcmVhZG9ubHkgYXV0aG9yTmFtZTogc3RyaW5nO1xuXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXG4gIHJlYWRvbmx5IGF1dGhvckVtYWlsOiBzdHJpbmc7XG5cbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcbiAgcmVhZG9ubHkgdmVyc2lvbjogc3RyaW5nO1xuXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXG4gIHJlYWRvbmx5IGRlc2NyaXB0aW9uPzogc3RyaW5nO1xuXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcbiAgcmVhZG9ubHkgbGljZW5zZT86IHN0cmluZztcblxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcbiAgcmVhZG9ubHkgaG9tZXBhZ2U/OiBzdHJpbmc7XG5cbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcbiAgcmVhZG9ubHkgY2xhc3NpZmllcnM/OiBzdHJpbmdbXTtcblxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcbiAgcmVhZG9ubHkgc2V0dXBDb25maWc/OiB7IFtrZXk6IHN0cmluZ106IGFueSB9O1xuXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcbiAgcmVhZG9ubHkgcG9ldHJ5T3B0aW9ucz86IFBvZXRyeVB5cHJvamVjdE9wdGlvbnNXaXRob3V0RGVwcztcbn1cbiJdfQ==