zcatalyst-cli 1.13.3 → 1.14.1

package/lib/init/dependencies/python/ensure-python.js

@@ -0,0 +1,151 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePythonWithPip = exports.ensurePython = void 0;
+const error_1 = __importDefault(require("../../../error"));
+const prompt_1 = __importDefault(require("../../../prompt"));
+const env_1 = require("../../../util_modules/env");
+const shell_1 = require("../../../util_modules/shell");
+const userConfig_1 = __importDefault(require("../../../userConfig"));
+const ansi_colors_1 = require("ansi-colors");
+const console_1 = require("console");
+function ensurePython(version, fallBackNeeded, skipHelp) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const configKey = `python${version.replace('.', '_')}.bin`;
+        const spawnCommand = userConfig_1.default.get(configKey);
+        try {
+            if (spawnCommand) {
+                yield validateCommand(version, spawnCommand, true);
+                return;
+            }
+        }
+        catch (_a) { }
+        return new Promise((resolve, reject) => {
+            const child = (0, shell_1.spawn)('python' + version, ['--version'], {
+                stdio: 'ignore'
+            }).RAW();
+            child.on('error', (error) => __awaiter(this, void 0, void 0, function* () {
+                if (env_1.isWindows) {
+                    try {
+                        yield (0, shell_1.spawn)('py -' + version, ['--version'], {
+                            stdio: 'ignore'
+                        }).ASYNC();
+                        userConfig_1.default.set(configKey, 'py -' + version);
+                        return resolve();
+                    }
+                    catch (_a) { }
+                }
+                if (fallBackNeeded) {
+                    (0, console_1.info)(`unable to locate python${version} in your system`);
+                    const ans = yield prompt_1.default.ask(prompt_1.default.question('binPath', `Please provide the binary path for python${version}:`, {
+                        type: 'input'
+                    }));
+                    yield validateCommand(version, ans.binPath, skipHelp)
+                        .then(() => {
+                        userConfig_1.default.set(`python${version.replace('.', '_')}.bin`, ans.binPath);
+                        resolve();
+                    })
+                        .catch((err) => {
+                        reject(err);
+                    });
+                }
+                else {
+                    reject(new error_1.default(`unable to locate python${version} in your system`, {
+                        original: error,
+                        exit: 1,
+                        errorId: 'PY-2',
+                        arg: [
+                            version,
+                            (0, ansi_colors_1.italic)((0, ansi_colors_1.bold)(`catalyst config:set ${configKey}=<binary_path>`))
+                        ],
+                        skipHelp
+                    }));
+                }
+            }));
+            child.on('exit', (code) => {
+                if (code == 0) {
+                    userConfig_1.default.set(configKey, 'python' + version);
+                }
+                resolve();
+            });
+        });
+    });
+}
+exports.ensurePython = ensurePython;
+function validateCommand(version, spawnCommand, skipHelp) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const versionResponse = yield new Promise((resolve, reject) => {
+            var _a;
+            const child = (0, shell_1.spawn)(spawnCommand, ['--version'], {
+                stdio: 'pipe'
+            }).RAW();
+            const dataBuf = [];
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (chunk) => {
+                dataBuf.push(chunk);
+            });
+            child.on('exit', (code) => {
+                if (code == 0) {
+                    const data = Buffer.concat(dataBuf).toString();
+                    return resolve(data);
+                }
+                else {
+                    reject(new error_1.default(`unable to locate python${version} with the given binary path`, {
+                        exit: 1,
+                        errorId: 'PY-1',
+                        arg: [version, (0, ansi_colors_1.bold)(spawnCommand)],
+                        skipHelp
+                    }));
+                }
+            });
+            child.on('error', (err) => {
+                reject(new error_1.default(`unable to locate python${version} with the given binary path`, {
+                    errorId: 'PY-1',
+                    original: err,
+                    exit: 1,
+                    arg: [version, (0, ansi_colors_1.bold)(spawnCommand)],
+                    skipHelp
+                }));
+            });
+        });
+        if (!versionResponse.split(' ')[1].startsWith(version)) {
+            throw new error_1.default(`unable to locate python${version} with the given binary path`, {
+                exit: 1,
+                errorId: 'PY-1',
+                arg: [version, (0, ansi_colors_1.bold)(spawnCommand)],
+                skipHelp
+            });
+        }
+    });
+}
+function ensurePythonWithPip(version, fallBackNeeded = false, skipHelp = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield ensurePython(version, fallBackNeeded, skipHelp);
+        return new Promise((resolve, reject) => {
+            const child = (0, shell_1.spawn)(userConfig_1.default.get(`python${version.replace('.', '_')}.bin`), ['-m', 'pip', '--version'], {
+                stdio: 'ignore'
+            }).RAW();
+            child.on('error', (err) => {
+                reject(new error_1.default(`unable to ensure pip for python${version}`, {
+                    errorId: 'PIP',
+                    original: err,
+                    arg: [version],
+                    exit: 1,
+                    skipHelp
+                }));
+            });
+            child.on('exit', resolve);
+        });
+    });
+}
+exports.ensurePythonWithPip = ensurePythonWithPip;

package/lib/init/dependencies/python/pip-install.js

@@ -0,0 +1,189 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installRequirements = exports.pypiRes = exports.ensurePyRuntime = void 0;
+const error_1 = __importDefault(require("../../../error"));
+const prompt_1 = __importDefault(require("../../../prompt"));
+const shell_1 = require("../../../util_modules/shell");
+const constants_1 = require("../../../util_modules/constants");
+const path_1 = require("path");
+const fs_1 = require("../../../util_modules/fs");
+const https_1 = __importDefault(require("https"));
+const runtime_1 = __importDefault(require("../../../util_modules/constants/lib/runtime"));
+const env_1 = require("../../../util_modules/env");
+const ensure_python_1 = require("./ensure-python");
+const userConfig_1 = __importDefault(require("../../../userConfig"));
+const sdkPipOpts = (0, env_1.envOverride)('CATALYST_SDK_PIP_OPTS', 'zcatalyst-sdk');
+const cliqSdkPipOpts = (0, env_1.envOverride)('CATALYST_CLIQ_SDK_PIP_OPTS', 'zcatalyst-cliq');
+const testPypi = (0, env_1.envOverride)('CATALYST_TEST_PYPI', 'false');
+exports.default = (pth, stack, isIntegFn = false, integService = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const stackVersion = stack.replace('python_', '');
+    const ans = yield prompt_1.default.ask(prompt_1.default.question('pipInstall', 'Do you wish to install all dependency libraries now ? ', {
+        type: 'confirm',
+        defaultAns: true,
+        when: () => !isIntegFn
+    }));
+    if (ans.pipInstall && !isIntegFn) {
+        yield (0, ensure_python_1.ensurePythonWithPip)(stackVersion.replace('_', '.'), true);
+        const spawnOpts = ['-m', 'pip', 'install', ...sdkPipOpts.split(' '), '-t', '.'];
+        return (0, shell_1.spawn)(userConfig_1.default.get(`python${stackVersion}.bin`), spawnOpts, {
+            cwd: pth
+        })
+            .ASYNC()
+            .catch((err) => {
+            throw new error_1.default('Failure while installing zcatalyst SDk', {
+                exit: 2,
+                original: err
+            });
+        });
+    }
+    else if ((isIntegFn || ans.pipInstall === undefined) &&
+        integService === constants_1.INTEG.services.cliq) {
+        yield (0, ensure_python_1.ensurePythonWithPip)(stackVersion.replace('_', '.'), true);
+        const spawnOpts = ['-m', 'pip', 'install', ...cliqSdkPipOpts.split(' '), '-t', '.'];
+        return (0, shell_1.spawn)(userConfig_1.default.get(`python${stackVersion}.bin`), spawnOpts, { cwd: pth })
+            .ASYNC()
+            .catch((err) => {
+            throw error_1.default.getErrorInstance(err, {
+                message: 'Failure while installing zcatalyst cliq SDK.'
+            });
+        });
+    }
+});
+function ensurePyRuntime(pth, stack) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const stackVersion = stack.replace('python_', '');
+        const runtimePkgName = 'zcatalyst-runtime-' + stackVersion.replace('_', '');
+        yield fs_1.ASYNC.ensureDir(pth);
+        const runtimeDir = (0, path_1.join)(pth, runtime_1.default.language.python, `zcatalyst_runtime_${stackVersion.replace('_', '')}`);
+        const isInitializerExists = yield fs_1.ASYNC.fileExists((0, path_1.join)(runtimeDir, 'main.py'));
+        if (isInitializerExists) {
+            const runtimeMetaData = yield fs_1.ASYNC.readJSONFile((0, path_1.join)(runtimeDir, 'meta.json'));
+            const pyRespJson = yield (0, exports.pypiRes)(runtimePkgName);
+            if ((runtimeMetaData === null || runtimeMetaData === void 0 ? void 0 : runtimeMetaData.version) == pyRespJson.info.version) {
+                return;
+            }
+        }
+        yield new Promise((resolve, reject) => {
+            var _a;
+            const spawnOpts = ['-m', 'pip', 'install', runtimePkgName, '--upgrade', '-t', './python'];
+            if (testPypi === 'true') {
+                spawnOpts.push('-i', 'https://test.pypi.org/simple/', '--extra-index-url', 'https://pypi.org/simple/');
+            }
+            const child = (0, shell_1.spawn)(userConfig_1.default.get(`python${stackVersion}.bin`), spawnOpts, {
+                cwd: pth,
+                stdio: 'pipe'
+            }).RAW();
+            const errData = [];
+            (_a = child.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (chunk) => {
+                errData.push(chunk);
+            });
+            child.on('error', (err) => {
+                reject(new error_1.default(`Error while installing python${stackVersion.replace('_', '.')} runtime`, {
+                    original: err,
+                    exit: 2
+                }));
+            });
+            child.on('exit', (code) => {
+                if (code != 0) {
+                    process.stderr.write(Buffer.concat(errData).toString());
+                    reject(new error_1.default(`Error while installing python${stackVersion.replace('_', '.')} runtime`, {
+                        exit: 1
+                    }));
+                }
+                resolve();
+            });
+        });
+        try {
+            const runtimeReqFile = (0, path_1.join)(runtimeDir, constants_1.FILENAME.functions.python_requirements);
+            if (yield fs_1.ASYNC.fileExists(runtimeReqFile)) {
+                yield installRequirements(runtimeReqFile, runtimeDir, stackVersion);
+            }
+        }
+        catch (err) {
+            yield fs_1.ASYNC.deleteDir(runtimeDir);
+            throw new error_1.default(`Error while installing python${stackVersion.replace('_', '.')} runtime dependencies`);
+        }
+    });
+}
+exports.ensurePyRuntime = ensurePyRuntime;
+const pypiRes = (pkg) => __awaiter(void 0, void 0, void 0, function* () {
+    const url = testPypi === 'true'
+        ? `https://test.pypi.org/pypi/${pkg}/json`
+        : `https://pypi.org/pypi/${pkg}/json`;
+    return new Promise((res) => {
+        https_1.default
+            .get(url, (resp) => {
+            const resBuffer = [];
+            resp.on('data', (chunk) => {
+                resBuffer.push(chunk);
+            });
+            resp.on('end', () => {
+                res(JSON.parse(Buffer.concat(resBuffer).toString()));
+            });
+        })
+            .on('error', (e) => {
+            throw new error_1.default('Error getting latest runtime version', {
+                original: e,
+                exit: 2
+            });
+        });
+    });
+});
+exports.pypiRes = pypiRes;
+function installRequirements(reqFile, pth, stackVersion, linuxMode = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const spawnOpts = ['-m', 'pip', 'install', '-r', reqFile, '-t', '.', '--upgrade'];
+        if (linuxMode) {
+            spawnOpts.push(...[
+                '--platform',
+                'manylinux2014_x86_64',
+                '--implementation',
+                'cp',
+                '--only-binary=:all:'
+            ]);
+        }
+        if (testPypi === 'true') {
+            spawnOpts.push('-i', 'https://test.pypi.org/simple/', '--extra-index-url', 'https://pypi.org/simple/');
+        }
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const child = (0, shell_1.spawn)(userConfig_1.default.get(`python${stackVersion}.bin`), spawnOpts, {
+                cwd: pth,
+                stdio: 'pipe'
+            }).RAW();
+            const errData = [];
+            (_a = child.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (chunk) => {
+                errData.push(chunk);
+            });
+            child.on('error', (err) => {
+                reject(new error_1.default('unable to process requirements.txt', {
+                    exit: 2,
+                    original: err
+                }));
+            });
+            child.on('exit', (code) => {
+                if (code != 0) {
+                    process.stderr.write(Buffer.concat(errData).toString());
+                    reject(new error_1.default('unable to process requirements.txt', {
+                        exit: 1,
+                        skipHelp: true
+                    }));
+                }
+                resolve();
+            });
+        }));
+    });
+}
+exports.installRequirements = installRequirements;

package/lib/init/features/functions/index.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const ansi_colors_1 = require("ansi-colors");
+const dc_1 = require("../../../dc");
 const catalyst_details_1 = __importDefault(require("../../../endpoints/lib/catalyst-details"));
 const integ_1 = require("../../../fn-utils/lib/integ");
 const prompt_1 = __importDefault(require("../../../prompt"));
@@ -20,6 +21,7 @@ const runtime_store_1 = __importDefault(require("../../../runtime-store"));
 const char_1 = require("../../../util_modules/char");
 const constants_1 = require("../../../util_modules/constants");
 const fs_1 = require("../../../util_modules/fs");
+const js_1 = require("../../../util_modules/js");
 const logger_1 = require("../../../util_modules/logger");
 const option_1 = require("../../../util_modules/option");
 const project_1 = require("../../../util_modules/project");
@@ -49,30 +51,33 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
     }
     const catalystDetailsAPI = new catalyst_details_1.default();
     const runtimeDetailsPromise = catalystDetailsAPI.getDetails('runtime');
+    const fnTypeChoices = [
+        prompt_1.default.choice('BasicIO', {
+            value: constants_1.FN_TYPE.basic,
+            short: 'basicIO'
+        }),
+        prompt_1.default.choice('AdvancedIO', {
+            value: constants_1.FN_TYPE.advanced,
+            short: 'advancedIO'
+        }),
+        prompt_1.default.choice('Event', {
+            value: constants_1.FN_TYPE.event,
+            short: 'event'
+        }),
+        prompt_1.default.choice('Cron', {
+            value: constants_1.FN_TYPE.cron,
+            short: 'cron'
+        })
+    ];
+    if ((0, dc_1.getActiveDC)() === constants_1.DC_TYPE.us.value) {
+        fnTypeChoices.push(prompt_1.default.choice('Integration', {
+            value: constants_1.FN_TYPE.integration,
+            short: 'integration'
+        }));
+    }
     const fnTypeAns = yield prompt_1.default.ask(prompt_1.default.question('type', 'Which type of function do you like to create?', {
         type: 'list',
-        choices: [
-            prompt_1.default.choice('BasicIO', {
-                value: constants_1.FN_TYPE.basic,
-                short: 'basicIO'
-            }),
-            prompt_1.default.choice('AdvancedIO', {
-                value: constants_1.FN_TYPE.advanced,
-                short: 'advancedIO'
-            }),
-            prompt_1.default.choice('Event', {
-                value: constants_1.FN_TYPE.event,
-                short: 'event'
-            }),
-            prompt_1.default.choice('Cron', {
-                value: constants_1.FN_TYPE.cron,
-                short: 'cron'
-            }),
-            prompt_1.default.choice('Integration', {
-                value: constants_1.FN_TYPE.integration,
-                short: 'integration'
-            })
-        ]
+        choices: fnTypeChoices
     }));
     runtime_store_1.default.set('context.functions.type', fnTypeAns.type);
     if (fnTypeAns.type === constants_1.FN_TYPE.integration) {
@@ -80,14 +85,21 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
     }
     const runtimeDetails = (yield runtimeDetailsPromise);
     const runtimeChoices = runtimeDetails.runtimes.reduce((acc, value) => {
-        const langArr = value.match(/[a-zA-Z]+/g);
-        if (langArr === null || languages_1.default[langArr[0]] === undefined) {
+        const langArr = value.match(/^([a-zA-Z]+)([0-9_]+)$/);
+        if (langArr === null ||
+            languages_1.default[langArr[1]] === undefined) {
             (0, logger_1.debug)('Language cannot be identified hence skipping');
             return acc;
         }
-        const runtimeLang = langArr[0];
+        const runtimeLang = langArr[1];
         const langFn = languages_1.default[runtimeLang];
         let displayValue = value;
+        if (displayValue.startsWith('python')) {
+            displayValue = 'Python ' + displayValue.replace('python_', '').replace('_', '.');
+        }
+        else {
+            displayValue = js_1.JS.startCase(langArr[1]) + ' ' + langArr[2];
+        }
         let disabled = false;
         if (runtimeDetails.eol_runtimes && runtimeDetails.eol_runtimes[value]) {
             switch (runtimeDetails.eol_runtimes[value]) {
@@ -110,14 +122,23 @@ exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
         if (acc[runtimeLang].length === 0) {
             const sep = {
                 node: '---NodeJS---',
-                java: '----Java----'
+                java: '----Java----',
+                python: '----Python----'
             };
             acc[runtimeLang].push(prompt_1.default.separator(sep[runtimeLang]));
         }
-        acc[runtimeLang].push(prompt_1.default.choice(displayValue, { value: langFn(value), short: value, disabled }));
+        acc[runtimeLang].push(prompt_1.default.choice(displayValue, { value: langFn(value), short: displayValue, disabled }));
         return acc;
-    }, { node: [], java: [] });
-    const runtimeChoicesArr = [...runtimeChoices.java, ...runtimeChoices.node];
+    }, {
+        node: [],
+        java: [],
+        python: []
+    });
+    const runtimeChoicesArr = [
+        ...runtimeChoices.python,
+        ...runtimeChoices.java,
+        ...runtimeChoices.node
+    ];
     const runtimeAns = yield prompt_1.default.ask(prompt_1.default.question('runtime', 'Which runtime do you prefer to write your function?', {
         type: 'list',
         choices: runtimeChoicesArr,

package/lib/init/features/functions/languages/index.js

@@ -5,7 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const java_1 = __importDefault(require("./java"));
 const node_1 = __importDefault(require("./node"));
+const python_1 = __importDefault(require("./python"));
 exports.default = {
     node: node_1.default,
-    java: java_1.default
+    java: java_1.default,
+    python: python_1.default
 };

package/lib/init/features/functions/languages/python.js

@@ -0,0 +1,115 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ansi_colors_1 = require("ansi-colors");
+const path_1 = require("path");
+const prompt_1 = __importDefault(require("../../../../prompt"));
+const fn_utils_1 = require("../../../../fn-utils");
+const runtime_store_1 = __importDefault(require("../../../../runtime-store"));
+const constants_1 = require("../../../../util_modules/constants");
+const fs_1 = require("../../../../util_modules/fs");
+const logger_1 = require("../../../../util_modules/logger");
+const js_1 = require("../../../../util_modules/js");
+const integ_1 = require("../../../../fn-utils/lib/integ");
+const runtime_1 = __importDefault(require("../../../../util_modules/constants/lib/runtime"));
+const functions_1 = require("../../../util/functions");
+const project_1 = require("../../../../util_modules/project");
+const ensure_python_1 = require("../../../dependencies/python/ensure-python");
+const error_1 = __importDefault(require("../../../../error"));
+const pip_install_1 = require("../../../dependencies/python/pip-install");
+const cli_table_1 = require("../../../../cli_table");
+const char_1 = require("../../../../util_modules/char");
+exports.default = (stack) => () => __awaiter(void 0, void 0, void 0, function* () {
+    const fnType = runtime_store_1.default.get('context.functions.type');
+    const fnDirPath = runtime_store_1.default.get('context.functions.dir_path');
+    yield fs_1.ASYNC.ensureDir(fnDirPath);
+    const service = runtime_store_1.default.get('context.functions.integration.service', '');
+    const templatePath = fnType === constants_1.FN_TYPE.integration
+        ? js_1.JS.get(constants_1.TEMPLATE.functions.python[fnType], service)
+        : constants_1.TEMPLATE.functions.python[fnType];
+    const functionAns = yield prompt_1.default.ask(prompt_1.default.question('name', 'package name: ', {
+        defaultAns: js_1.JS.snakeCase((0, project_1.getProjectName)('sample') + '_function'),
+        validate: (ans) => {
+            if (ans.match(constants_1.REGEX.folder_name)) {
+                return true;
+            }
+            return 'Invalid package name';
+        }
+    }), prompt_1.default.question('main', 'entry point: ', {
+        defaultAns: 'main.py',
+        validate: (ans) => {
+            if (js_1.JS.endsWith(ans, '.py')) {
+                return true;
+            }
+            return 'Invalid entry point';
+        }
+    }));
+    const targetPath = (0, path_1.join)(fnDirPath, functionAns.name);
+    const dirExists = yield fs_1.ASYNC.dirExists(targetPath);
+    const overwriteAns = dirExists
+        ? yield prompt_1.default.ask(prompt_1.default.question('overwrite', 'Directory ' +
+            (0, ansi_colors_1.underline)(functionAns.name) +
+            ' already exists inside functions directory. Overwrite ?', {
+            type: 'confirm',
+            defaultAns: false
+        }))
+        : { overwrite: true };
+    if (!overwriteAns.overwrite) {
+        (0, logger_1.warning)('Skipping functions python setup...');
+        return;
+    }
+    yield fs_1.ASYNC.deleteDir(targetPath).catch();
+    if (fnType === constants_1.FN_TYPE.integration) {
+        yield (0, integ_1.copyIntegHandlers)(templatePath, targetPath, runtime_1.default.language.python);
+    }
+    else {
+        yield fs_1.ASYNC.copyDir(templatePath, targetPath);
+    }
+    const pyRespJson = fnType === constants_1.FN_TYPE.integration
+        ? yield (0, pip_install_1.pypiRes)('zcatalyst-cliq')
+        : yield (0, pip_install_1.pypiRes)('zcatalyst-sdk');
+    yield fs_1.ASYNC.findAndReplace(targetPath)([
+        constants_1.PLACEHOLDER.functions.python_package.name,
+        constants_1.PLACEHOLDER.functions.python_package.main,
+        constants_1.PLACEHOLDER.functions.python_package.sdkVersion
+    ], [
+        functionAns.name,
+        functionAns.main,
+        pyRespJson.info.version
+    ]);
+    yield fs_1.ASYNC.rename((0, path_1.join)(targetPath, constants_1.FILENAME.functions.python_main), () => functionAns.main);
+    const integ_config = runtime_store_1.default.get('context.functions.integration.config', '');
+    yield fn_utils_1.fnUtils.common.findAndReplaceConfigProps(targetPath, {
+        stack,
+        type: fnType,
+        integ_config
+    });
+    const stackVersion = stack.replace('python_', '');
+    try {
+        yield (0, ensure_python_1.ensurePython)(stackVersion.replace('_', '.'), false, true);
+    }
+    catch (err) {
+        const error = error_1.default.getErrorInstance(err);
+        const table = (0, cli_table_1.getCustomColourTable)(ansi_colors_1.yellow);
+        table.push([
+            (0, ansi_colors_1.yellow)(char_1.CHAR.warning + ' ') +
+                error.message +
+                '\n' +
+                `you can set it later with the command ` +
+                `"${(0, ansi_colors_1.italic)((0, ansi_colors_1.bold)(`catalyst config:set python${stackVersion}.bin=<binary_path>`))}"`
+        ]);
+        (0, logger_1.info)(table.toString());
+    }
+    return (0, functions_1.fillFunctionsInitPayload)(targetPath, functionAns.name, stack, fnType);
+});

package/lib/init/features/index.js

@@ -85,7 +85,7 @@ function setFnConfig(featureName, add) {
             case 'functions':
                 if (!add) {
                     config.set(featureName + '.targets', [context.name]);
-                    config.set(featureName + '.ignore', ((_a = context.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.java)) ? ['.output'] : []);
+                    config.set(featureName + '.ignore', ((_a = context.stack) === null || _a === void 0 ? void 0 : _a.startsWith(runtime_1.default.language.java)) ? [constants_1.FOLDERNAME.output] : []);
                     config.set(featureName + '.source', targetSource);
                     return;
                 }
@@ -93,7 +93,7 @@ function setFnConfig(featureName, add) {
                 config.set(featureName + '.targets', js_1.JS.uniq(targetArr.concat([context.name])));
                 const ignoreArr = config.get(featureName + '.ignore', []);
                 config.set(featureName + '.ignore', ((_b = context.stack) === null || _b === void 0 ? void 0 : _b.startsWith(runtime_1.default.language.java))
-                    ? js_1.JS.uniq(ignoreArr.concat(['.output']))
+                    ? js_1.JS.uniq(ignoreArr.concat([constants_1.FOLDERNAME.output]))
                     : ignoreArr);
                 if (config.get(featureName + '.source') !== targetSource) {
                     (0, logger_1.warning)(featureName + ' source has been modified');