motia 0.2.1-beta.49 → 0.2.1-beta.50

package/dist/cjs/install.js

@@ -10,14 +10,20 @@ const executeCommand_1 = require("./utils/executeCommand");
 const activatePythonEnv_1 = require("./utils/activatePythonEnv");
 const installLambdaPythonPackages_1 = require("./utils/installLambdaPythonPackages");
 const generate_locked_data_1 = require("./generate-locked-data");
+const pythonVersionUtils_1 = require("./utils/pythonVersionUtils");
 const pythonInstall = async ({ baseDir, isVerbose = false, pythonVersion = '3.13' }) => {
     const venvPath = path_1.default.join(baseDir, 'python_modules');
     console.log('📦 Installing Python dependencies...', venvPath);
     try {
+        // Get the appropriate Python command
+        const pythonCmd = await (0, pythonVersionUtils_1.getPythonCommand)(pythonVersion, baseDir);
+        if (isVerbose) {
+            console.log(`🐍 Using Python command: ${pythonCmd}`);
+        }
         // Check if virtual environment exists
         if (!fs_1.default.existsSync(venvPath)) {
             console.log('📦 Creating Python virtual environment...');
-            await (0, executeCommand_1.executeCommand)(`python${pythonVersion} -m venv python_modules`, baseDir);
+            await (0, executeCommand_1.executeCommand)(`${pythonCmd} -m venv python_modules`, baseDir);
         }
         (0, activatePythonEnv_1.activatePythonVenv)({ baseDir, isVerbose, pythonVersion });
         (0, installLambdaPythonPackages_1.installLambdaPythonPackages)({ baseDir, isVerbose });

package/dist/cjs/utils/activatePythonEnv.js

@@ -6,11 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.activatePythonVenv = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const pythonVersionUtils_1 = require("./pythonVersionUtils");
 const activatePythonVenv = ({ baseDir, isVerbose = false, pythonVersion = '3.13' }) => {
     // Set the virtual environment path
     const venvPath = path_1.default.join(baseDir, 'python_modules');
     const venvBinPath = path_1.default.join(venvPath, process.platform === 'win32' ? 'Scripts' : 'bin');
-    const sitePackagesPath = path_1.default.join(venvPath, 'lib', `python${pythonVersion}`, 'site-packages');
+    const libPath = path_1.default.join(venvPath, 'lib');
+    // Find the Python version directory using the utility function
+    const actualPythonVersionPath = (0, pythonVersionUtils_1.findPythonSitePackagesDir)(libPath, pythonVersion, isVerbose);
+    const sitePackagesPath = path_1.default.join(venvPath, 'lib', actualPythonVersionPath, 'site-packages');
     // Verify that the virtual environment exists
     if (fs_1.default.existsSync(venvPath)) {
         // Add virtual environment to PATH

package/dist/cjs/utils/executeCommand.d.ts

@@ -1 +1,5 @@
-export declare const executeCommand: (command: string, rootDir: string) => Promise<unknown>;
+interface ExecuteCommandOptions {
+    silent?: boolean;
+}
+export declare const executeCommand: (command: string, rootDir: string, options?: ExecuteCommandOptions) => Promise<string>;
+export {};

package/dist/cjs/utils/executeCommand.js

@@ -2,19 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeCommand = void 0;
 const child_process_1 = require("child_process");
-const executeCommand = async (command, rootDir) => {
+const executeCommand = async (command, rootDir, options) => {
+    const { silent = false } = options || {};
     return new Promise((resolve, reject) => {
         (0, child_process_1.exec)(command, { cwd: rootDir }, (error, stdout, stderr) => {
             if (error) {
-                console.error(`exec error: ${error}`);
+                if (!silent) {
+                    console.error(`exec error: ${error}`);
+                }
                 reject(error);
                 return;
             }
-            if (stdout)
-                console.log(stdout.toString());
-            if (stderr)
-                console.error(stderr.toString());
-            resolve(stdout);
+            if (!silent) {
+                if (stdout)
+                    console.log(stdout.toString());
+                if (stderr)
+                    console.error(stderr.toString());
+            }
+            resolve(stdout.toString());
         });
     });
 };

package/dist/cjs/utils/pythonVersionUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function checkPythonVersionExists(pythonCmd: string, baseDir: string): Promise<boolean>;
+export declare function getPythonCommand(requestedVersion: string, baseDir: string): Promise<string>;
+export declare function findPythonSitePackagesDir(venvLibPath: string, pythonVersion: string, isVerbose?: boolean): string;

package/dist/cjs/utils/pythonVersionUtils.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPythonVersionExists = checkPythonVersionExists;
+exports.getPythonCommand = getPythonCommand;
+exports.findPythonSitePackagesDir = findPythonSitePackagesDir;
+const executeCommand_1 = require("./executeCommand");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+async function checkPythonVersionExists(pythonCmd, baseDir) {
+    try {
+        await (0, executeCommand_1.executeCommand)(`${pythonCmd} --version`, baseDir, { silent: true });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+async function getPythonCommand(requestedVersion, baseDir) {
+    // Check if python{version} exists (e.g., python3.13)
+    const specificPythonCmd = `python${requestedVersion}`;
+    if (await checkPythonVersionExists(specificPythonCmd, baseDir)) {
+        return specificPythonCmd;
+    }
+    // Check if python exists and is version 3+
+    try {
+        const result = await (0, executeCommand_1.executeCommand)('python --version', baseDir, { silent: true });
+        const versionMatch = result.match(/Python\s+(\d+)\.(\d+)\.(\d+)/);
+        if (versionMatch && parseInt(versionMatch[1], 10) >= 3) {
+            return 'python';
+        }
+    }
+    catch (error) {
+        // If error, python command doesn't exist or can't be executed
+    }
+    throw new Error('No compatible Python 3 installation found. Please install Python 3.');
+}
+function findPythonSitePackagesDir(venvLibPath, pythonVersion, isVerbose = false) {
+    let pythonVersionPath = `python${pythonVersion}`;
+    if (!venvLibPath || !pythonVersion) {
+        return pythonVersionPath;
+    }
+    try {
+        // Check if the exact version exists
+        if (venvLibPath && !fs_1.default.existsSync(path_1.default.join(venvLibPath, pythonVersionPath))) {
+            // Try to find any python3.x directory
+            const libContents = fs_1.default.readdirSync(venvLibPath);
+            const pythonDirs = libContents.filter(item => item.startsWith('python3'));
+            if (pythonDirs.length > 0) {
+                // Use the first python3.x directory found
+                pythonVersionPath = pythonDirs[0];
+                if (isVerbose) {
+                    console.log(`Found Python directory: ${pythonVersionPath}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (isVerbose) {
+            console.warn(`Warning: Could not determine Python version directory: ${error}`);
+        }
+    }
+    return pythonVersionPath;
+}

package/dist/esm/install.js

@@ -4,14 +4,20 @@ import { executeCommand } from './utils/executeCommand';
 import { activatePythonVenv } from './utils/activatePythonEnv';
 import { installLambdaPythonPackages } from './utils/installLambdaPythonPackages';
 import { getStepFiles } from './generate-locked-data';
+import { getPythonCommand } from './utils/pythonVersionUtils';
 const pythonInstall = async ({ baseDir, isVerbose = false, pythonVersion = '3.13' }) => {
     const venvPath = path.join(baseDir, 'python_modules');
     console.log('📦 Installing Python dependencies...', venvPath);
     try {
+        // Get the appropriate Python command
+        const pythonCmd = await getPythonCommand(pythonVersion, baseDir);
+        if (isVerbose) {
+            console.log(`🐍 Using Python command: ${pythonCmd}`);
+        }
         // Check if virtual environment exists
         if (!fs.existsSync(venvPath)) {
             console.log('📦 Creating Python virtual environment...');
-            await executeCommand(`python${pythonVersion} -m venv python_modules`, baseDir);
+            await executeCommand(`${pythonCmd} -m venv python_modules`, baseDir);
         }
         activatePythonVenv({ baseDir, isVerbose, pythonVersion });
         installLambdaPythonPackages({ baseDir, isVerbose });

package/dist/esm/utils/activatePythonEnv.js

@@ -1,10 +1,14 @@
 import path from 'path';
 import fs from 'fs';
+import { findPythonSitePackagesDir } from './pythonVersionUtils';
 export const activatePythonVenv = ({ baseDir, isVerbose = false, pythonVersion = '3.13' }) => {
     // Set the virtual environment path
     const venvPath = path.join(baseDir, 'python_modules');
     const venvBinPath = path.join(venvPath, process.platform === 'win32' ? 'Scripts' : 'bin');
-    const sitePackagesPath = path.join(venvPath, 'lib', `python${pythonVersion}`, 'site-packages');
+    const libPath = path.join(venvPath, 'lib');
+    // Find the Python version directory using the utility function
+    const actualPythonVersionPath = findPythonSitePackagesDir(libPath, pythonVersion, isVerbose);
+    const sitePackagesPath = path.join(venvPath, 'lib', actualPythonVersionPath, 'site-packages');
     // Verify that the virtual environment exists
     if (fs.existsSync(venvPath)) {
         // Add virtual environment to PATH

package/dist/esm/utils/executeCommand.d.ts

@@ -1 +1,5 @@
-export declare const executeCommand: (command: string, rootDir: string) => Promise<unknown>;
+interface ExecuteCommandOptions {
+    silent?: boolean;
+}
+export declare const executeCommand: (command: string, rootDir: string, options?: ExecuteCommandOptions) => Promise<string>;
+export {};

package/dist/esm/utils/executeCommand.js

@@ -1,17 +1,22 @@
 import { exec } from 'child_process';
-export const executeCommand = async (command, rootDir) => {
+export const executeCommand = async (command, rootDir, options) => {
+    const { silent = false } = options || {};
     return new Promise((resolve, reject) => {
         exec(command, { cwd: rootDir }, (error, stdout, stderr) => {
             if (error) {
-                console.error(`exec error: ${error}`);
+                if (!silent) {
+                    console.error(`exec error: ${error}`);
+                }
                 reject(error);
                 return;
             }
-            if (stdout)
-                console.log(stdout.toString());
-            if (stderr)
-                console.error(stderr.toString());
-            resolve(stdout);
+            if (!silent) {
+                if (stdout)
+                    console.log(stdout.toString());
+                if (stderr)
+                    console.error(stderr.toString());
+            }
+            resolve(stdout.toString());
         });
     });
 };

package/dist/esm/utils/pythonVersionUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function checkPythonVersionExists(pythonCmd: string, baseDir: string): Promise<boolean>;
+export declare function getPythonCommand(requestedVersion: string, baseDir: string): Promise<string>;
+export declare function findPythonSitePackagesDir(venvLibPath: string, pythonVersion: string, isVerbose?: boolean): string;

package/dist/esm/utils/pythonVersionUtils.js

@@ -0,0 +1,58 @@
+import { executeCommand } from './executeCommand';
+import fs from 'fs';
+import path from 'path';
+export async function checkPythonVersionExists(pythonCmd, baseDir) {
+    try {
+        await executeCommand(`${pythonCmd} --version`, baseDir, { silent: true });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export async function getPythonCommand(requestedVersion, baseDir) {
+    // Check if python{version} exists (e.g., python3.13)
+    const specificPythonCmd = `python${requestedVersion}`;
+    if (await checkPythonVersionExists(specificPythonCmd, baseDir)) {
+        return specificPythonCmd;
+    }
+    // Check if python exists and is version 3+
+    try {
+        const result = await executeCommand('python --version', baseDir, { silent: true });
+        const versionMatch = result.match(/Python\s+(\d+)\.(\d+)\.(\d+)/);
+        if (versionMatch && parseInt(versionMatch[1], 10) >= 3) {
+            return 'python';
+        }
+    }
+    catch (error) {
+        // If error, python command doesn't exist or can't be executed
+    }
+    throw new Error('No compatible Python 3 installation found. Please install Python 3.');
+}
+export function findPythonSitePackagesDir(venvLibPath, pythonVersion, isVerbose = false) {
+    let pythonVersionPath = `python${pythonVersion}`;
+    if (!venvLibPath || !pythonVersion) {
+        return pythonVersionPath;
+    }
+    try {
+        // Check if the exact version exists
+        if (venvLibPath && !fs.existsSync(path.join(venvLibPath, pythonVersionPath))) {
+            // Try to find any python3.x directory
+            const libContents = fs.readdirSync(venvLibPath);
+            const pythonDirs = libContents.filter(item => item.startsWith('python3'));
+            if (pythonDirs.length > 0) {
+                // Use the first python3.x directory found
+                pythonVersionPath = pythonDirs[0];
+                if (isVerbose) {
+                    console.log(`Found Python directory: ${pythonVersionPath}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (isVerbose) {
+            console.warn(`Warning: Could not determine Python version directory: ${error}`);
+        }
+    }
+    return pythonVersionPath;
+}

package/dist/types/utils/executeCommand.d.ts

@@ -1 +1,5 @@
-export declare const executeCommand: (command: string, rootDir: string) => Promise<unknown>;
+interface ExecuteCommandOptions {
+    silent?: boolean;
+}
+export declare const executeCommand: (command: string, rootDir: string, options?: ExecuteCommandOptions) => Promise<string>;
+export {};

package/dist/types/utils/pythonVersionUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function checkPythonVersionExists(pythonCmd: string, baseDir: string): Promise<boolean>;
+export declare function getPythonCommand(requestedVersion: string, baseDir: string): Promise<string>;
+export declare function findPythonSitePackagesDir(venvLibPath: string, pythonVersion: string, isVerbose?: boolean): string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "motia",
   "description": "Code-first framework for intelligent workflows",
-  "version": "0.2.1-beta.49",
+  "version": "0.2.1-beta.50",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -42,9 +42,9 @@
     "inquirer": "^8.2.5",
     "ts-node": "^10.9.2",
     "yaml": "^2.7.0",
-    "@motiadev/core": "0.2.1-beta.49",
-    "motia": "0.2.1-beta.49",
-    "@motiadev/workbench": "0.2.1-beta.49"
+    "@motiadev/core": "0.2.1-beta.50",
+    "@motiadev/workbench": "0.2.1-beta.50",
+    "motia": "0.2.1-beta.50"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",