projen 0.0.0

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

@@ -0,0 +1,202 @@
+import { GitHubProject, GitHubProjectOptions } from '../github';
+import { ProjenrcOptions } from './projenrc';
+import { Pytest, PytestOptions } from './pytest';
+import { IPythonDeps } from './python-deps';
+import { IPythonEnv } from './python-env';
+import { IPythonPackaging, PythonPackagingOptions } from './python-packaging';
+import { VenvOptions } from './venv';
+/**
+ * (experimental) Options for `PythonProject`.
+ *
+ * @experimental
+ */
+export interface PythonProjectOptions extends GitHubProjectOptions, PythonPackagingOptions {
+    /**
+     * (experimental) Name of the python package as used in imports and filenames.
+     *
+     * Must only consist of alphanumeric characters and underscores.
+     *
+     * @default $PYTHON_MODULE_NAME
+     * @experimental
+     */
+    readonly moduleName: string;
+    /**
+     * (experimental) List of runtime dependencies for this project.
+     *
+     * Dependencies use the format: `<module>@<semver>`
+     *
+     * Additional dependencies can be added via `project.addDependency()`.
+     *
+     * @default []
+     * @experimental
+     * @featured true
+     */
+    readonly deps?: string[];
+    /**
+     * (experimental) List of dev dependencies for this project.
+     *
+     * Dependencies use the format: `<module>@<semver>`
+     *
+     * Additional dependencies can be added via `project.addDevDependency()`.
+     *
+     * @default []
+     * @experimental
+     * @featured true
+     */
+    readonly devDeps?: string[];
+    /**
+     * (experimental) Use pip with a requirements.txt file to track project dependencies.
+     *
+     * @default true
+     * @experimental
+     * @featured true
+     */
+    readonly pip?: boolean;
+    /**
+     * (experimental) Use venv to manage a virtual environment for installing dependencies inside.
+     *
+     * @default true
+     * @experimental
+     * @featured true
+     */
+    readonly venv?: boolean;
+    /**
+     * (experimental) Venv options.
+     *
+     * @default - defaults
+     * @experimental
+     */
+    readonly venvOptions?: VenvOptions;
+    /**
+     * (experimental) Use setuptools with a setup.py script for packaging and publishing.
+     *
+     * @default - true if the project type is library
+     * @experimental
+     * @featured true
+     */
+    readonly setuptools?: boolean;
+    /**
+     * (experimental) Use poetry to manage your project dependencies, virtual environment, and (optional) packaging/publishing.
+     *
+     * @default false
+     * @experimental
+     * @featured true
+     */
+    readonly poetry?: boolean;
+    /**
+     * (experimental) Include pytest tests.
+     *
+     * @default true
+     * @experimental
+     * @featured true
+     */
+    readonly pytest?: boolean;
+    /**
+     * (experimental) pytest options.
+     *
+     * @default - defaults
+     * @experimental
+     */
+    readonly pytestOptions?: PytestOptions;
+    /**
+     * (experimental) Include sample code and test if the relevant directories don't exist.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly sample?: boolean;
+    /**
+     * (experimental) Use projenrc in python.
+     *
+     * This will install `projen` as a python dependency and will add a `synth`
+     * task which will run `.projenrc.py`.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly projenrcPython?: boolean;
+    /**
+     * (experimental) Options related to projenrc in python.
+     *
+     * @default - default options
+     * @experimental
+     */
+    readonly projenrcPythonOptions?: ProjenrcOptions;
+}
+/**
+ * (experimental) Python project.
+ *
+ * @experimental
+ * @pjid python
+ */
+export declare class PythonProject extends GitHubProject {
+    /**
+     * (experimental) Python module name (the project name, with any hyphens or periods replaced with underscores).
+     *
+     * @experimental
+     */
+    readonly moduleName: string;
+    /**
+     * (experimental) Version of the package for distribution (should follow semver).
+     *
+     * @experimental
+     */
+    readonly version: string;
+    /**
+     * (experimental) API for managing dependencies.
+     *
+     * @experimental
+     */
+    readonly depsManager: IPythonDeps;
+    /**
+     * (experimental) API for mangaging the Python runtime environment.
+     *
+     * @experimental
+     */
+    readonly envManager: IPythonEnv;
+    /**
+     * (experimental) API for managing packaging the project as a library.
+     *
+     * Only applies when the `projectType` is LIB.
+     *
+     * @experimental
+     */
+    readonly packagingManager?: IPythonPackaging;
+    /**
+     * (experimental) Pytest component.
+     *
+     * @experimental
+     */
+    readonly pytest?: Pytest;
+    /**
+     * @experimental
+     */
+    constructor(options: PythonProjectOptions);
+    /**
+     * Adds default gitignore options for a Python project based on
+     * https://github.com/github/gitignore/blob/master/Python.gitignore
+     */
+    private addDefaultGitIgnore;
+    /**
+     * (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) Called after all components are synthesized.
+     *
+     * Order is *not* guaranteed.
+     *
+     * @experimental
+     */
+    postSynthesize(): void;
+}

package/lib/python/python-project.js

@@ -0,0 +1,155 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythonProject = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const github_1 = require("../github");
+const project_1 = require("../project");
+const pip_1 = require("./pip");
+const poetry_1 = require("./poetry");
+const projenrc_1 = require("./projenrc");
+const pytest_1 = require("./pytest");
+const python_sample_1 = require("./python-sample");
+const setuptools_1 = require("./setuptools");
+const venv_1 = require("./venv");
+/** Allowed characters in python project names */
+const PYTHON_PROJECT_NAME_REGEX = /^[A-Za-z0-9-_\.]+$/;
+/**
+ * (experimental) Python project.
+ *
+ * @experimental
+ * @pjid python
+ */
+class PythonProject extends github_1.GitHubProject {
+    /**
+     * @experimental
+     */
+    constructor(options) {
+        var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+        super(options);
+        if (!PYTHON_PROJECT_NAME_REGEX.test(options.name)) {
+            throw new Error('Python projects must only consist of alphanumeric characters, hyphens, and underscores.');
+        }
+        this.moduleName = options.moduleName;
+        this.version = options.version;
+        if ((_b = options.projenrcPython) !== null && _b !== void 0 ? _b : true) {
+            new projenrc_1.Projenrc(this, options.projenrcPythonOptions);
+        }
+        if ((_c = options.venv) !== null && _c !== void 0 ? _c : true) {
+            this.envManager = new venv_1.Venv(this, options.venvOptions);
+        }
+        if ((_d = options.pip) !== null && _d !== void 0 ? _d : true) {
+            this.depsManager = new pip_1.Pip(this);
+        }
+        if ((_e = options.setuptools) !== null && _e !== void 0 ? _e : (this.projectType === project_1.ProjectType.LIB)) {
+            this.packagingManager = new setuptools_1.Setuptools(this, {
+                version: options.version,
+                description: options.description,
+                authorName: options.authorName,
+                authorEmail: options.authorEmail,
+                license: options.license,
+                homepage: options.homepage,
+                classifiers: options.classifiers,
+                setupConfig: options.setupConfig,
+            });
+        }
+        // if (options.conda ?? false) {
+        //   this.depsManager = new Conda(this, options);
+        //   this.envManager = this.depsManager;
+        // }
+        // if (options.pipenv ?? false) {
+        //   this.depsManager = new Pipenv(this, options);
+        //   this.envManager = this.depsManager;
+        // }
+        if ((_f = options.poetry) !== null && _f !== void 0 ? _f : false) {
+            const poetry = new poetry_1.Poetry(this, {
+                version: options.version,
+                description: options.description,
+                authorName: options.authorName,
+                authorEmail: options.authorEmail,
+                license: options.license,
+                homepage: options.homepage,
+                classifiers: options.classifiers,
+                poetryOptions: {
+                    readme: (_h = (_g = options.readme) === null || _g === void 0 ? void 0 : _g.filename) !== null && _h !== void 0 ? _h : 'README.md',
+                    ...options.poetryOptions,
+                },
+            });
+            this.depsManager = poetry;
+            this.envManager = poetry;
+            this.packagingManager = poetry;
+        }
+        if (!this.envManager) {
+            throw new Error('At least one tool must be chosen for managing the environment (venv, conda, pipenv, or poetry).');
+        }
+        if (!this.depsManager) {
+            throw new Error('At least one tool must be chosen for managing dependencies (pip, conda, pipenv, or poetry).');
+        }
+        if (!this.packagingManager && this.projectType === project_1.ProjectType.LIB) {
+            throw new Error('At least one tool must be chosen for managing packaging (setuptools or poetry).');
+        }
+        if (Number((_j = options.venv) !== null && _j !== void 0 ? _j : true) + Number((_k = options.poetry) !== null && _k !== void 0 ? _k : false) > 1) {
+            throw new Error('More than one component has been chosen for managing the environment (venv, conda, pipenv, or poetry)');
+        }
+        if (Number((_l = options.pip) !== null && _l !== void 0 ? _l : true) + Number((_m = options.poetry) !== null && _m !== void 0 ? _m : false) > 1) {
+            throw new Error('More than one component has been chosen for managing dependencies (pip, conda, pipenv, or poetry)');
+        }
+        if (Number((_o = options.setuptools) !== null && _o !== void 0 ? _o : true) + Number((_p = options.poetry) !== null && _p !== void 0 ? _p : false) > 1) {
+            throw new Error('More than one component has been chosen for managing packaging (setuptools or poetry)');
+        }
+        if ((_q = options.pytest) !== null && _q !== void 0 ? _q : true) {
+            this.pytest = new pytest_1.Pytest(this, options.pytestOptions);
+        }
+        if ((_r = options.sample) !== null && _r !== void 0 ? _r : true) {
+            new python_sample_1.PythonSample(this, {});
+        }
+        for (const dep of (_s = options.deps) !== null && _s !== void 0 ? _s : []) {
+            this.addDependency(dep);
+        }
+        for (const dep of (_t = options.devDeps) !== null && _t !== void 0 ? _t : []) {
+            this.addDevDependency(dep);
+        }
+        this.addDefaultGitIgnore();
+    }
+    /**
+     * Adds default gitignore options for a Python project based on
+     * https://github.com/github/gitignore/blob/master/Python.gitignore
+     */
+    addDefaultGitIgnore() {
+        this.gitignore.exclude('# Byte-compiled / optimized / DLL files', '__pycache__/', '*.py[cod]', '*$py.class', '', '# C extensions', '*.so', '', '# Distribution / packaging', '.Python', 'build/', 'develop-eggs/', 'dist/', 'downloads/', 'eggs/', '.eggs/', 'lib/', 'lib64/', 'parts/', 'sdist/', 'var/', 'wheels/', 'share/python-wheels/', '*.egg-info/', '.installed.cfg', '*.egg', 'MANIFEST', '', '# PyInstaller', '#  Usually these files are written by a python script from a template', '#  before PyInstaller builds the exe, so as to inject date/other infos into it.', '*.manifest', '*.spec', '', '# Installer logs', 'pip-log.txt', 'pip-delete-this-directory.txt', '', '# Unit test / coverage reports', 'htmlcov/', '.tox/', '.nox/', '.coverage', '.coverage.*', '.cache', 'nosetests.xml', 'coverage.xml', '*.cover', '*.py,cover', '.hypothesis/', '.pytest_cache/', 'cover/', '', '# Translations', '*.mo', '*.pot', '', '# Django stuff:', '*.log', 'local_settings.py', 'db.sqlite3', 'db.sqlite3-journal', '', '# Flask stuff:', 'instance/', '.webassets-cache', '', '# Scrapy stuff:', '.scrapy', '', '# Sphinx documentation', 'docs/_build/', '', '# PyBuilder', '.pybuilder/', 'target/', '', '# Jupyter Notebook', '.ipynb_checkpoints', '', '# IPython', 'profile_default/', 'ipython_config.py', '', '# PEP 582; used by e.g. github.com/David-OConnor/pyflow', '__pypackages__/', '', '# Celery stuff', 'celerybeat-schedule', 'celerybeat.pid', '', '# SageMath parsed files', '*.sage.py', '', '# Environments', '.env', '.venv', 'env/', 'venv/', 'ENV/', 'env.bak/', 'venv.bak/', '', '# Spyder project settings', '.spyderproject', '.spyproject', '', '# Rope project settings', '.ropeproject', '', '# mkdocs documentation', '/site', '', '# mypy', '.mypy_cache/', '.dmypy.json', 'dmypy.json', '', '# Pyre type checker', '.pyre/', '', '# pytype static type analyzer', '.pytype/', '', '# Cython debug symbols', 'cython_debug/');
+    }
+    /**
+     * (experimental) Adds a runtime dependency.
+     *
+     * @param spec Format `<module>@<semver>`.
+     * @experimental
+     */
+    addDependency(spec) {
+        return this.depsManager.addDependency(spec);
+    }
+    /**
+     * (experimental) Adds a dev dependency.
+     *
+     * @param spec Format `<module>@<semver>`.
+     * @experimental
+     */
+    addDevDependency(spec) {
+        return this.depsManager.addDevDependency(spec);
+    }
+    /**
+     * (experimental) Called after all components are synthesized.
+     *
+     * Order is *not* guaranteed.
+     *
+     * @experimental
+     */
+    postSynthesize() {
+        super.postSynthesize();
+        this.envManager.setupEnvironment();
+        this.depsManager.installDependencies();
+    }
+}
+exports.PythonProject = PythonProject;
+_a = JSII_RTTI_SYMBOL_1;
+PythonProject[_a] = { fqn: "projen.python.PythonProject", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"python-project.js","sourceRoot":"","sources":["../../src/python/python-project.ts"],"names":[],"mappings":";;;;;AAAA,sCAAgE;AAChE,wCAAyC;AACzC,+BAA4B;AAC5B,qCAAkC;AAClC,yCAAyE;AACzE,qCAAiD;AAIjD,mDAA+C;AAC/C,6CAA0C;AAC1C,iCAA2C;AAG3C,iDAAiD;AACjD,MAAM,yBAAyB,GAAG,oBAAoB,CAAC;;;;;;;AAqDvD,MAAa,aAAc,SAAQ,sBAAa;;;;IAmB9C,YAAY,OAA6B;;QACvC,KAAK,CAAC,OAAO,CAAC,CAAC;QAEf,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACjD,MAAM,IAAI,KAAK,CAAC,yFAAyF,CAAC,CAAC;SAC5G;QAED,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;QACrC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAE/B,UAAI,OAAO,CAAC,cAAc,mCAAI,IAAI,EAAE;YAClC,IAAI,mBAAc,CAAC,IAAI,EAAE,OAAO,CAAC,qBAAqB,CAAC,CAAC;SACzD;QAED,UAAI,OAAO,CAAC,IAAI,mCAAI,IAAI,EAAE;YACxB,IAAI,CAAC,UAAU,GAAG,IAAI,WAAI,CAAC,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;SACvD;QAED,UAAI,OAAO,CAAC,GAAG,mCAAI,IAAI,EAAE;YACvB,IAAI,CAAC,WAAW,GAAG,IAAI,SAAG,CAAC,IAAI,CAAC,CAAC;SAClC;QAED,UAAI,OAAO,CAAC,UAAU,mCAAI,CAAC,IAAI,CAAC,WAAW,KAAK,qBAAW,CAAC,GAAG,CAAC,EAAE;YAChE,IAAI,CAAC,gBAAgB,GAAG,IAAI,uBAAU,CAAC,IAAI,EAAE;gBAC3C,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,WAAW,EAAE,OAAO,CAAC,WAAW;gBAChC,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,WAAW,EAAE,OAAO,CAAC,WAAW;gBAChC,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,WAAW,EAAE,OAAO,CAAC,WAAW;gBAChC,WAAW,EAAE,OAAO,CAAC,WAAW;aACjC,CAAC,CAAC;SACJ;QAED,gCAAgC;QAChC,iDAAiD;QACjD,wCAAwC;QACxC,IAAI;QAEJ,iCAAiC;QACjC,kDAAkD;QAClD,wCAAwC;QACxC,IAAI;QAEJ,UAAI,OAAO,CAAC,MAAM,mCAAI,KAAK,EAAE;YAC3B,MAAM,MAAM,GAAG,IAAI,eAAM,CAAC,IAAI,EAAE;gBAC9B,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,WAAW,EAAE,OAAO,CAAC,WAAW;gBAChC,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,WAAW,EAAE,OAAO,CAAC,WAAW;gBAChC,OAAO,EAAE,OAAO,CAAC,OAAO;gBACxB,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,WAAW,EAAE,OAAO,CAAC,WAAW;gBAChC,aAAa,EAAE;oBACb,MAAM,cAAE,OAAO,CAAC,MAAM,0CAAE,QAAQ,mCAAI,WAAW;oBAC/C,GAAG,OAAO,CAAC,aAAa;iBACzB;aACF,CAAC,CAAC;YACH,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;YAC1B,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC;YACzB,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC;SAChC;QAED,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YACpB,MAAM,IAAI,KAAK,CAAC,iGAAiG,CAAC,CAAC;SACpH;QAED,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACrB,MAAM,IAAI,KAAK,CAAC,6FAA6F,CAAC,CAAC;SAChH;QAED,IAAI,CAAC,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,WAAW,KAAK,qBAAW,CAAC,GAAG,EAAE;YAClE,MAAM,IAAI,KAAK,CAAC,iFAAiF,CAAC,CAAC;SACpG;QAED,IAAI,MAAM,OAAC,OAAO,CAAC,IAAI,mCAAI,IAAI,CAAC,GAAG,MAAM,OAAC,OAAO,CAAC,MAAM,mCAAI,KAAK,CAAC,GAAG,CAAC,EAAE;YACtE,MAAM,IAAI,KAAK,CAAC,uGAAuG,CAAC,CAAC;SAC1H;QAED,IAAI,MAAM,OAAC,OAAO,CAAC,GAAG,mCAAI,IAAI,CAAC,GAAG,MAAM,OAAC,OAAO,CAAC,MAAM,mCAAI,KAAK,CAAC,GAAG,CAAC,EAAE;YACrE,MAAM,IAAI,KAAK,CAAC,mGAAmG,CAAC,CAAC;SACtH;QAED,IAAI,MAAM,OAAC,OAAO,CAAC,UAAU,mCAAI,IAAI,CAAC,GAAG,MAAM,OAAC,OAAO,CAAC,MAAM,mCAAI,KAAK,CAAC,GAAG,CAAC,EAAE;YAC5E,MAAM,IAAI,KAAK,CAAC,uFAAuF,CAAC,CAAC;SAC1G;QAED,UAAI,OAAO,CAAC,MAAM,mCAAI,IAAI,EAAE;YAC1B,IAAI,CAAC,MAAM,GAAG,IAAI,eAAM,CAAC,IAAI,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;SACvD;QAED,UAAI,OAAO,CAAC,MAAM,mCAAI,IAAI,EAAE;YAC1B,IAAI,4BAAY,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;SAC5B;QAED,KAAK,MAAM,GAAG,UAAI,OAAO,CAAC,IAAI,mCAAI,EAAE,EAAE;YACpC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;SACzB;QAED,KAAK,MAAM,GAAG,UAAI,OAAO,CAAC,OAAO,mCAAI,EAAE,EAAE;YACvC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;SAC5B;QAED,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED;;;OAGG;IACK,mBAAmB;QACzB,IAAI,CAAC,SAAS,CAAC,OAAO,CACpB,yCAAyC,EACzC,cAAc,EACd,WAAW,EACX,YAAY,EACZ,EAAE,EACF,gBAAgB,EAChB,MAAM,EACN,EAAE,EACF,4BAA4B,EAC5B,SAAS,EACT,QAAQ,EACR,eAAe,EACf,OAAO,EACP,YAAY,EACZ,OAAO,EACP,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,SAAS,EACT,sBAAsB,EACtB,aAAa,EACb,gBAAgB,EAChB,OAAO,EACP,UAAU,EACV,EAAE,EACF,eAAe,EACf,uEAAuE,EACvE,iFAAiF,EACjF,YAAY,EACZ,QAAQ,EACR,EAAE,EACF,kBAAkB,EAClB,aAAa,EACb,+BAA+B,EAC/B,EAAE,EACF,gCAAgC,EAChC,UAAU,EACV,OAAO,EACP,OAAO,EACP,WAAW,EACX,aAAa,EACb,QAAQ,EACR,eAAe,EACf,cAAc,EACd,SAAS,EACT,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,QAAQ,EACR,EAAE,EACF,gBAAgB,EAChB,MAAM,EACN,OAAO,EACP,EAAE,EACF,iBAAiB,EACjB,OAAO,EACP,mBAAmB,EACnB,YAAY,EACZ,oBAAoB,EACpB,EAAE,EACF,gBAAgB,EAChB,WAAW,EACX,kBAAkB,EAClB,EAAE,EACF,iBAAiB,EACjB,SAAS,EACT,EAAE,EACF,wBAAwB,EACxB,cAAc,EACd,EAAE,EACF,aAAa,EACb,aAAa,EACb,SAAS,EACT,EAAE,EACF,oBAAoB,EACpB,oBAAoB,EACpB,EAAE,EACF,WAAW,EACX,kBAAkB,EAClB,mBAAmB,EACnB,EAAE,EACF,yDAAyD,EACzD,iBAAiB,EACjB,EAAE,EACF,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,EAAE,EACF,yBAAyB,EACzB,WAAW,EACX,EAAE,EACF,gBAAgB,EAChB,MAAM,EACN,OAAO,EACP,MAAM,EACN,OAAO,EACP,MAAM,EACN,UAAU,EACV,WAAW,EACX,EAAE,EACF,2BAA2B,EAC3B,gBAAgB,EAChB,aAAa,EACb,EAAE,EACF,yBAAyB,EACzB,cAAc,EACd,EAAE,EACF,wBAAwB,EACxB,OAAO,EACP,EAAE,EACF,QAAQ,EACR,cAAc,EACd,aAAa,EACb,YAAY,EACZ,EAAE,EACF,qBAAqB,EACrB,QAAQ,EACR,EAAE,EACF,+BAA+B,EAC/B,UAAU,EACV,EAAE,EACF,wBAAwB,EACxB,eAAe,CAChB,CAAC;IACJ,CAAC;;;;;;;IAGM,aAAa,CAAC,IAAY;QAC/B,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;;;;;;;IAGM,gBAAgB,CAAC,IAAY;QAClC,OAAO,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACjD,CAAC;;;;;;;;IAEM,cAAc;QACnB,KAAK,CAAC,cAAc,EAAE,CAAC;QAEvB,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,CAAC;QACnC,IAAI,CAAC,WAAW,CAAC,mBAAmB,EAAE,CAAC;IACzC,CAAC;;AApRH,sCAqRC","sourcesContent":["import { GitHubProject, GitHubProjectOptions } from '../github';\nimport { ProjectType } from '../project';\nimport { Pip } from './pip';\nimport { Poetry } from './poetry';\nimport { Projenrc as ProjenrcPython, ProjenrcOptions } from './projenrc';\nimport { Pytest, PytestOptions } from './pytest';\nimport { IPythonDeps } from './python-deps';\nimport { IPythonEnv } from './python-env';\nimport { IPythonPackaging, PythonPackagingOptions } from './python-packaging';\nimport { PythonSample } from './python-sample';\nimport { Setuptools } from './setuptools';\nimport { Venv, VenvOptions } from './venv';\n\n\n/** Allowed characters in python project names */\nconst PYTHON_PROJECT_NAME_REGEX = /^[A-Za-z0-9-_\\.]+$/;\n\n                                       \nexport interface PythonProjectOptions extends GitHubProjectOptions, PythonPackagingOptions {\n  // -- required options --\n\n                                                                                                                                                                                            \n  readonly moduleName: string;\n\n  // -- dependencies --\n\n                                                                                                                                                                                                                                             \n  readonly deps?: string[];\n\n                                                                                                                                                                                                                                            \n  readonly devDeps?: string[];\n\n  // -- core components --\n\n                                                                                                                           \n  readonly pip?: boolean;\n\n                                                                                                                                    \n  readonly venv?: boolean;\n\n                                                      \n  readonly venvOptions?: VenvOptions;\n\n                                                                                                                                                            \n  readonly setuptools?: boolean;\n\n                                                                                                                                                                       \n  readonly poetry?: boolean;\n\n  // -- optional components --\n\n                                                                        \n  readonly pytest?: boolean;\n\n                                                        \n  readonly pytestOptions?: PytestOptions;\n\n                                                                                                         \n  readonly sample?: boolean;\n\n                                                                                                                                                                                            \n  readonly projenrcPython?: boolean;\n\n                                                                                          \n  readonly projenrcPythonOptions?: ProjenrcOptions;\n}\n\n                                             \nexport class PythonProject extends GitHubProject {\n                                                                                                                   \n  public readonly moduleName: string;\n\n                                                                                \n  public readonly version: string;\n\n                                               \n  public readonly depsManager!: IPythonDeps;\n\n                                                                  \n  public readonly envManager!: IPythonEnv;\n\n                                                                                                                 \n  public readonly packagingManager?: IPythonPackaging;\n\n                                  \n  public readonly pytest?: Pytest;\n\n  constructor(options: PythonProjectOptions) {\n    super(options);\n\n    if (!PYTHON_PROJECT_NAME_REGEX.test(options.name)) {\n      throw new Error('Python projects must only consist of alphanumeric characters, hyphens, and underscores.');\n    }\n\n    this.moduleName = options.moduleName;\n    this.version = options.version;\n\n    if (options.projenrcPython ?? true) {\n      new ProjenrcPython(this, options.projenrcPythonOptions);\n    }\n\n    if (options.venv ?? true) {\n      this.envManager = new Venv(this, options.venvOptions);\n    }\n\n    if (options.pip ?? true) {\n      this.depsManager = new Pip(this);\n    }\n\n    if (options.setuptools ?? (this.projectType === ProjectType.LIB)) {\n      this.packagingManager = new Setuptools(this, {\n        version: options.version,\n        description: options.description,\n        authorName: options.authorName,\n        authorEmail: options.authorEmail,\n        license: options.license,\n        homepage: options.homepage,\n        classifiers: options.classifiers,\n        setupConfig: options.setupConfig,\n      });\n    }\n\n    // if (options.conda ?? false) {\n    //   this.depsManager = new Conda(this, options);\n    //   this.envManager = this.depsManager;\n    // }\n\n    // if (options.pipenv ?? false) {\n    //   this.depsManager = new Pipenv(this, options);\n    //   this.envManager = this.depsManager;\n    // }\n\n    if (options.poetry ?? false) {\n      const poetry = new Poetry(this, {\n        version: options.version,\n        description: options.description,\n        authorName: options.authorName,\n        authorEmail: options.authorEmail,\n        license: options.license,\n        homepage: options.homepage,\n        classifiers: options.classifiers,\n        poetryOptions: {\n          readme: options.readme?.filename ?? 'README.md',\n          ...options.poetryOptions,\n        },\n      });\n      this.depsManager = poetry;\n      this.envManager = poetry;\n      this.packagingManager = poetry;\n    }\n\n    if (!this.envManager) {\n      throw new Error('At least one tool must be chosen for managing the environment (venv, conda, pipenv, or poetry).');\n    }\n\n    if (!this.depsManager) {\n      throw new Error('At least one tool must be chosen for managing dependencies (pip, conda, pipenv, or poetry).');\n    }\n\n    if (!this.packagingManager && this.projectType === ProjectType.LIB) {\n      throw new Error('At least one tool must be chosen for managing packaging (setuptools or poetry).');\n    }\n\n    if (Number(options.venv ?? true) + Number(options.poetry ?? false) > 1) {\n      throw new Error('More than one component has been chosen for managing the environment (venv, conda, pipenv, or poetry)');\n    }\n\n    if (Number(options.pip ?? true) + Number(options.poetry ?? false) > 1) {\n      throw new Error('More than one component has been chosen for managing dependencies (pip, conda, pipenv, or poetry)');\n    }\n\n    if (Number(options.setuptools ?? true) + Number(options.poetry ?? false) > 1) {\n      throw new Error('More than one component has been chosen for managing packaging (setuptools or poetry)');\n    }\n\n    if (options.pytest ?? true) {\n      this.pytest = new Pytest(this, options.pytestOptions);\n    }\n\n    if (options.sample ?? true) {\n      new PythonSample(this, {});\n    }\n\n    for (const dep of options.deps ?? []) {\n      this.addDependency(dep);\n    }\n\n    for (const dep of options.devDeps ?? []) {\n      this.addDevDependency(dep);\n    }\n\n    this.addDefaultGitIgnore();\n  }\n\n  /**\n   * Adds default gitignore options for a Python project based on\n   * https://github.com/github/gitignore/blob/master/Python.gitignore\n   */\n  private addDefaultGitIgnore() {\n    this.gitignore.exclude(\n      '# Byte-compiled / optimized / DLL files',\n      '__pycache__/',\n      '*.py[cod]',\n      '*$py.class',\n      '',\n      '# C extensions',\n      '*.so',\n      '',\n      '# Distribution / packaging',\n      '.Python',\n      'build/',\n      'develop-eggs/',\n      'dist/',\n      'downloads/',\n      'eggs/',\n      '.eggs/',\n      'lib/',\n      'lib64/',\n      'parts/',\n      'sdist/',\n      'var/',\n      'wheels/',\n      'share/python-wheels/',\n      '*.egg-info/',\n      '.installed.cfg',\n      '*.egg',\n      'MANIFEST',\n      '',\n      '# PyInstaller',\n      '#  Usually these files are written by a python script from a template',\n      '#  before PyInstaller builds the exe, so as to inject date/other infos into it.',\n      '*.manifest',\n      '*.spec',\n      '',\n      '# Installer logs',\n      'pip-log.txt',\n      'pip-delete-this-directory.txt',\n      '',\n      '# Unit test / coverage reports',\n      'htmlcov/',\n      '.tox/',\n      '.nox/',\n      '.coverage',\n      '.coverage.*',\n      '.cache',\n      'nosetests.xml',\n      'coverage.xml',\n      '*.cover',\n      '*.py,cover',\n      '.hypothesis/',\n      '.pytest_cache/',\n      'cover/',\n      '',\n      '# Translations',\n      '*.mo',\n      '*.pot',\n      '',\n      '# Django stuff:',\n      '*.log',\n      'local_settings.py',\n      'db.sqlite3',\n      'db.sqlite3-journal',\n      '',\n      '# Flask stuff:',\n      'instance/',\n      '.webassets-cache',\n      '',\n      '# Scrapy stuff:',\n      '.scrapy',\n      '',\n      '# Sphinx documentation',\n      'docs/_build/',\n      '',\n      '# PyBuilder',\n      '.pybuilder/',\n      'target/',\n      '',\n      '# Jupyter Notebook',\n      '.ipynb_checkpoints',\n      '',\n      '# IPython',\n      'profile_default/',\n      'ipython_config.py',\n      '',\n      '# PEP 582; used by e.g. github.com/David-OConnor/pyflow',\n      '__pypackages__/',\n      '',\n      '# Celery stuff',\n      'celerybeat-schedule',\n      'celerybeat.pid',\n      '',\n      '# SageMath parsed files',\n      '*.sage.py',\n      '',\n      '# Environments',\n      '.env',\n      '.venv',\n      'env/',\n      'venv/',\n      'ENV/',\n      'env.bak/',\n      'venv.bak/',\n      '',\n      '# Spyder project settings',\n      '.spyderproject',\n      '.spyproject',\n      '',\n      '# Rope project settings',\n      '.ropeproject',\n      '',\n      '# mkdocs documentation',\n      '/site',\n      '',\n      '# mypy',\n      '.mypy_cache/',\n      '.dmypy.json',\n      'dmypy.json',\n      '',\n      '# Pyre type checker',\n      '.pyre/',\n      '',\n      '# pytype static type analyzer',\n      '.pytype/',\n      '',\n      '# Cython debug symbols',\n      'cython_debug/',\n    );\n  }\n\n                                                                                            \n  public addDependency(spec: string) {\n    return this.depsManager.addDependency(spec);\n  }\n\n                                                                                        \n  public addDevDependency(spec: string) {\n    return this.depsManager.addDevDependency(spec);\n  }\n\n  public postSynthesize() {\n    super.postSynthesize();\n\n    this.envManager.setupEnvironment();\n    this.depsManager.installDependencies();\n  }\n}\n"]}

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

@@ -0,0 +1,20 @@
+import { Component } from '../component';
+import { PythonProject } from './python-project';
+/**
+ * (experimental) Options for python sample code.
+ *
+ * @experimental
+ */
+export interface PythonSampleOptions {
+}
+/**
+ * (experimental) Python code sample.
+ *
+ * @experimental
+ */
+export declare class PythonSample extends Component {
+    /**
+     * @experimental
+     */
+    constructor(project: PythonProject, _options: PythonSampleOptions);
+}

package/lib/python/python-sample.js

@@ -0,0 +1,48 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythonSample = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const component_1 = require("../component");
+const sample_file_1 = require("../sample-file");
+/**
+ * (experimental) Python code sample.
+ *
+ * @experimental
+ */
+class PythonSample extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, _options) {
+        super(project);
+        new sample_file_1.SampleDir(project, project.moduleName, {
+            files: {
+                '__init__.py': '__version__ = "0.1.0"\n',
+                '__main__.py': [
+                    'from .example import hello',
+                    '',
+                    'if __name__ == "__main__":',
+                    '    name = input("What is your name? ")',
+                    '    print(hello(name))',
+                    '',
+                ].join('\n'),
+                'example.py': [
+                    'def hello(name: str) -> str:',
+                    '    """A simple greeting.',
+                    '    Args:',
+                    '        name (str): Name to greet.',
+                    '    Returns:',
+                    '        str: greeting message',
+                    '    """',
+                    '    return f"Hello {name}!"',
+                    '',
+                ].join('\n'),
+            },
+        });
+    }
+}
+exports.PythonSample = PythonSample;
+_a = JSII_RTTI_SYMBOL_1;
+PythonSample[_a] = { fqn: "projen.python.PythonSample", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/python/requirements-file.d.ts

@@ -0,0 +1,44 @@
+import { FileBase, IResolver } from '../file';
+import { Project } from '../project';
+import { IPackageProvider } from './python-deps';
+/**
+ * @experimental
+ */
+export interface RequirementsFileOptions {
+    /**
+     * (experimental) Provide a list of packages that can be dynamically updated.
+     *
+     * @experimental
+     */
+    readonly packageProvider?: IPackageProvider;
+}
+/**
+ * (experimental) Specifies a list of packages to be installed using pip.
+ *
+ * @see https://pip.pypa.io/en/stable/reference/pip_install/#requirements-file-format
+ * @experimental
+ */
+export declare class RequirementsFile extends FileBase {
+    private readonly packages;
+    private readonly packageProvider?;
+    /**
+     * @experimental
+     */
+    constructor(project: Project, filePath: string, options: RequirementsFileOptions);
+    /**
+     * (experimental) Adds the specified packages provided in semver format.
+     *
+     * Comment lines (start with `#`) are ignored.
+     *
+     * @param packages Package version in format `<module>@<semver>`.
+     * @experimental
+     */
+    addPackages(...packages: string[]): void;
+    private formatDependency;
+    /**
+     * (experimental) Implemented by derived classes and returns the contents of the file to emit.
+     *
+     * @experimental
+     */
+    protected synthesizeContent(resolver: IResolver): string | undefined;
+}

package/lib/python/requirements-file.js

@@ -0,0 +1,75 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequirementsFile = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const dependencies_1 = require("../dependencies");
+const file_1 = require("../file");
+const semver_1 = require("../util/semver");
+/**
+ * (experimental) Specifies a list of packages to be installed using pip.
+ *
+ * @see https://pip.pypa.io/en/stable/reference/pip_install/#requirements-file-format
+ * @experimental
+ */
+class RequirementsFile extends file_1.FileBase {
+    /**
+     * @experimental
+     */
+    constructor(project, filePath, options) {
+        super(project, filePath);
+        this.packages = new Array();
+        this.packageProvider = options.packageProvider;
+    }
+    /**
+     * (experimental) Adds the specified packages provided in semver format.
+     *
+     * Comment lines (start with `#`) are ignored.
+     *
+     * @param packages Package version in format `<module>@<semver>`.
+     * @experimental
+     */
+    addPackages(...packages) {
+        for (let pkg of packages) {
+            if (pkg.startsWith('#')) {
+                this.packages.push(pkg);
+            }
+            else {
+                const { name, version } = dependencies_1.Dependencies.parseDependency(pkg);
+                if (version) {
+                    this.packages.push(`${name}${semver_1.toPythonVersionRange(version)}`);
+                }
+                else {
+                    this.packages.push(name);
+                }
+            }
+        }
+    }
+    formatDependency(dep) {
+        if (dep.version) {
+            return `${dep.name}${semver_1.toPythonVersionRange(dep.version)}`;
+        }
+        else {
+            return dep.name;
+        }
+    }
+    /**
+     * (experimental) Implemented by derived classes and returns the contents of the file to emit.
+     *
+     * @experimental
+     */
+    synthesizeContent(resolver) {
+        const allPackages = [...this.packages];
+        if (this.packageProvider) {
+            allPackages.push(...this.packageProvider.packages.map(dep => this.formatDependency(dep)));
+        }
+        return `${resolver.resolve([
+            `# ${file_1.FileBase.PROJEN_MARKER}`,
+            ...allPackages,
+        ]).join('\n')}\n`;
+    }
+}
+exports.RequirementsFile = RequirementsFile;
+_a = JSII_RTTI_SYMBOL_1;
+RequirementsFile[_a] = { fqn: "projen.python.RequirementsFile", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,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