motia 0.5.11-beta.120-382150 → 0.5.11-beta.120-357906

package/dist/cjs/cloud/build/builders/python/index.d.ts

@@ -4,9 +4,18 @@ import { BuildListener } from '../../../new-deployment/listeners/listener.types'
 export declare class PythonBuilder implements StepBuilder {
     private readonly builder;
     private readonly listener;
+    private uvPackager;
+    private uvConfig;
     constructor(builder: Builder, listener: BuildListener);
-    private buildStep;
-    build(step: Step): Promise<void>;
+    private loadUvConfig;
     buildApiSteps(steps: Step<ApiRouteConfig>[]): Promise<RouterBuildResult>;
-    private getPythonBuilderData;
+    build(step: Step): Promise<void>;
+    private addStepToArchive;
+    private addPackagesToArchive;
+    private shouldIgnoreFile;
+    private normalizeStepPath;
+    private createRouterTemplate;
+    private findInternalFiles;
+    private resolveModulePaths;
+    private getModuleName;
 }

package/dist/cjs/cloud/build/builders/python/index.js

@@ -4,115 +4,252 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PythonBuilder = void 0;
-const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const activate_python_env_1 = require("../../../../utils/activate-python-env");
 const archiver_1 = require("../archiver");
 const include_static_files_1 = require("../include-static-files");
-const add_package_to_archive_1 = require("./add-package-to-archive");
 const constants_1 = require("../../../new-deployment/constants");
+const uv_packager_1 = require("./uv-packager");
 class PythonBuilder {
     constructor(builder, listener) {
         this.builder = builder;
         this.listener = listener;
-        (0, activate_python_env_1.activatePythonVenv)({ baseDir: this.builder.projectDir });
+        this.uvConfig = { ...uv_packager_1.defaultUvConfig, ...this.loadUvConfig() };
+        this.uvPackager = new uv_packager_1.UvPackager(this.builder.projectDir, this.uvConfig);
     }
-    async buildStep(step, archive) {
-        const entrypointPath = step.filePath.replace(this.builder.projectDir, '');
-        const normalizedEntrypointPath = entrypointPath.replace(/[.]step.py$/, '_step.py');
-        const sitePackagesDir = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
-        // Get Python builder response
-        const { packages } = await this.getPythonBuilderData(step);
-        // Add main file to archive
-        if (!fs_1.default.existsSync(step.filePath)) {
-            throw new Error(`Source file not found: ${step.filePath}`);
+    loadUvConfig() {
+        const configFiles = ['uv.config.json', '.uvrc.json'];
+        for (const configFile of configFiles) {
+            const configPath = path_1.default.join(this.builder.projectDir, configFile);
+            if (fs_1.default.existsSync(configPath)) {
+                try {
+                    const configContent = fs_1.default.readFileSync(configPath, 'utf-8');
+                    return JSON.parse(configContent);
+                }
+                catch (err) {
+                    console.warn(`Warning: Failed to load UV config from ${configFile}`);
+                }
+            }
+        }
+        return {};
+    }
+    async buildApiSteps(steps) {
+        const zipName = 'router-python.zip';
+        const archive = new archiver_1.Archiver(path_1.default.join(constants_1.distDir, zipName));
+        if (!await this.uvPackager.checkUvInstalled()) {
+            throw new Error('UV is not installed. Please install UV: curl -LsSf https://astral.sh/uv/install.sh | sh');
+        }
+        const tempSitePackages = path_1.default.join(constants_1.distDir, `temp-python-packages-${Date.now()}`);
+        try {
+            await this.uvPackager.packageDependencies(tempSitePackages);
+            // Pequena pausa para garantir que o filesystem sincronize
+            await new Promise(resolve => setTimeout(resolve, 100));
+            await this.addPackagesToArchive(archive, tempSitePackages);
+            for (const step of steps) {
+                await this.addStepToArchive(step, archive);
+            }
+            const routerTemplate = this.createRouterTemplate(steps);
+            archive.append(routerTemplate, 'router.py');
+            (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archive);
+            const size = await archive.finalize();
+            return { size, path: zipName };
+        }
+        catch (error) {
+            throw new Error(`Failed to build Python API router: ${error}`);
+        }
+        finally {
+            if (fs_1.default.existsSync(tempSitePackages)) {
+                fs_1.default.rmSync(tempSitePackages, { recursive: true, force: true });
+            }
         }
-        archive.append(fs_1.default.createReadStream(step.filePath), path_1.default.relative(this.builder.projectDir, normalizedEntrypointPath));
-        await Promise.all(packages.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(archive, sitePackagesDir, packageName)));
-        return normalizedEntrypointPath;
     }
     async build(step) {
         const entrypointPath = step.filePath.replace(this.builder.projectDir, '');
         const bundlePath = path_1.default.join('python', entrypointPath.replace(/(.*)\.py$/, '$1.zip'));
-        const normalizedEntrypointPath = entrypointPath.replace(/[.]step.py$/, '_step.py');
         const outfile = path_1.default.join(constants_1.distDir, bundlePath);
+        this.builder.registerStep({ entrypointPath, bundlePath, step, type: 'python' });
+        this.listener.onBuildStart(step);
         try {
-            // Create output directory
+            if (!await this.uvPackager.checkUvInstalled()) {
+                throw new Error('UV is not installed. Please install UV: curl -LsSf https://astral.sh/uv/install.sh | sh');
+            }
             fs_1.default.mkdirSync(path_1.default.dirname(outfile), { recursive: true });
-            this.listener.onBuildStart(step);
-            // Get Python builder response
-            const { packages } = await this.getPythonBuilderData(step);
-            const stepArchiver = new archiver_1.Archiver(outfile);
-            const stepPath = await this.buildStep(step, stepArchiver);
-            // Add main file to archive
-            if (!fs_1.default.existsSync(step.filePath)) {
-                throw new Error(`Source file not found: ${step.filePath}`);
+            const archive = new archiver_1.Archiver(outfile);
+            const tempSitePackages = path_1.default.join(constants_1.distDir, `temp-python-packages-${Date.now()}`);
+            try {
+                await this.uvPackager.packageDependencies(tempSitePackages);
+                await new Promise(resolve => setTimeout(resolve, 100));
+                await this.addStepToArchive(step, archive);
+                await this.addPackagesToArchive(archive, tempSitePackages);
+                (0, include_static_files_1.includeStaticFiles)([step], this.builder, archive);
+                const size = await archive.finalize();
+                this.listener.onBuildEnd(step, size);
             }
-            stepArchiver.append(fs_1.default.createReadStream(step.filePath), path_1.default.relative(this.builder.projectDir, normalizedEntrypointPath));
-            // Add all imported files to archive
-            this.listener.onBuildProgress(step, 'Adding imported files to archive...');
-            const sitePackagesDir = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
-            (0, include_static_files_1.includeStaticFiles)([step], this.builder, stepArchiver);
-            if (packages.length > 0) {
-                await Promise.all(packages.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(stepArchiver, sitePackagesDir, packageName)));
-                this.listener.onBuildProgress(step, `Added ${packages.length} packages to archive`);
+            finally {
+                if (fs_1.default.existsSync(tempSitePackages)) {
+                    fs_1.default.rmSync(tempSitePackages, { recursive: true, force: true });
+                }
             }
-            // Finalize the archive and wait for completion
-            const size = await stepArchiver.finalize();
-            this.builder.registerStep({ entrypointPath: stepPath, bundlePath, step, type: 'python' });
-            this.listener.onBuildEnd(step, size);
         }
         catch (err) {
             this.listener.onBuildError(step, err);
             throw err;
         }
     }
-    async buildApiSteps(steps) {
-        const getStepPath = (step) => {
-            const normalizedEntrypointPath = step.filePath.replace(/[.]step.py$/, '_step.py');
-            return normalizedEntrypointPath
-                .replace(`${this.builder.projectDir}/`, '')
-                .replace(/(.*)\.py$/, '$1')
-                .replace(/\//g, '.');
-        };
-        const zipName = 'router-python.zip';
-        const archive = new archiver_1.Archiver(path_1.default.join(constants_1.distDir, zipName));
-        const dependencies = ['uvicorn', 'pydantic', 'pydantic_core', 'uvloop', 'starlette', 'typing_inspection'];
-        const lambdaSitePackages = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
-        await Promise.all(dependencies.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(archive, lambdaSitePackages, packageName)));
-        for (const step of steps) {
-            await this.buildStep(step, archive);
+    async addStepToArchive(step, archive) {
+        const normalizedPath = this.normalizeStepPath(step, false);
+        archive.append(fs_1.default.createReadStream(step.filePath), normalizedPath);
+        const internalFiles = await this.findInternalFiles(step.filePath);
+        for (const file of internalFiles) {
+            const fullPath = path_1.default.join(this.builder.projectDir, file);
+            if (fs_1.default.existsSync(fullPath) && fullPath !== step.filePath) {
+                const archivePath = file.replace(/\.step\.py$/, '_step.py');
+                archive.append(fs_1.default.createReadStream(fullPath), archivePath);
+            }
+        }
+    }
+    async addPackagesToArchive(archive, sitePackagesDir) {
+        if (!fs_1.default.existsSync(sitePackagesDir)) {
+            console.warn(`Warning: Site packages directory not found: ${sitePackagesDir}`);
+            return;
+        }
+        // Verificar se o diretório está acessível
+        try {
+            fs_1.default.accessSync(sitePackagesDir, fs_1.default.constants.R_OK);
+        }
+        catch (error) {
+            console.warn(`Warning: Cannot access site packages directory: ${sitePackagesDir}`);
+            return;
         }
-        const file = fs_1.default
+        const addDirectory = (dirPath, basePath = sitePackagesDir) => {
+            try {
+                const items = fs_1.default.readdirSync(dirPath);
+                for (const item of items) {
+                    const fullPath = path_1.default.join(dirPath, item);
+                    const relativePath = path_1.default.relative(basePath, fullPath);
+                    if (this.shouldIgnoreFile(relativePath)) {
+                        continue;
+                    }
+                    try {
+                        const stat = fs_1.default.statSync(fullPath);
+                        if (stat.isDirectory()) {
+                            addDirectory(fullPath, basePath);
+                        }
+                        else {
+                            archive.append(fs_1.default.createReadStream(fullPath), relativePath);
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`Warning: Could not process file ${fullPath}: ${error}`);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`Warning: Could not read directory ${dirPath}: ${error}`);
+            }
+        };
+        addDirectory(sitePackagesDir);
+    }
+    shouldIgnoreFile(filePath) {
+        const ignorePatterns = [
+            /\.pyc$/,
+            /\.pyo$/,
+            /\.egg$/,
+            /\.egg-info$/,
+            /__pycache__/,
+            /\.dist-info$/,
+            /^tests?\//,
+            /^docs?\//,
+            /^examples?\//,
+            /\.pytest_cache/,
+        ];
+        return ignorePatterns.some((pattern) => pattern.test(filePath));
+    }
+    normalizeStepPath(step, normalizePythonModulePath) {
+        let normalizedStepPath = step.filePath
+            .replace(/[.]step.py$/, '_step.py') // Replace .step.py with _step.py
+            .replace(`${this.builder.projectDir}/`, ''); // Remove the project directory from the path
+        const pathParts = normalizedStepPath.split(path_1.default.sep).map((part) => part
+            .replace(/^[0-9]+/g, '') // Remove numeric prefixes
+            .replace(/[^a-zA-Z0-9._]/g, '_') // Replace any non-alphanumeric characters (except dots) with underscores
+            .replace(/^_/, '')); // Remove leading underscore
+        normalizedStepPath = normalizePythonModulePath
+            ? pathParts.join('.') // Convert path delimiter to dot (python module separator)
+            : '/' + pathParts.join(path_1.default.sep);
+        return normalizedStepPath;
+    }
+    createRouterTemplate(steps) {
+        const imports = steps
+            .map((step, index) => {
+            const moduleName = this.getModuleName(step);
+            return `from ${moduleName} import handler as route${index}_handler, config as route${index}_config`;
+        })
+            .join('\n');
+        const routerPaths = steps
+            .map((step, index) => {
+            const method = step.config.method.toUpperCase();
+            const path = step.config.path;
+            return `    '${method} ${path}': RouterPath('${step.config.name}', '${step.config.method.toLowerCase()}', route${index}_handler, route${index}_config)`;
+        })
+            .join(',\n');
+        return fs_1.default
             .readFileSync(path_1.default.join(__dirname, 'router_template.py'), 'utf-8')
-            .replace('# {{imports}}', steps
-            .map((step, index) => `from ${getStepPath(step)} import handler as route${index}_handler, config as route${index}_config`)
-            .join('\n'))
-            .replace('# {{router paths}}', steps
-            .map((step, index) => `'${step.config.method} ${step.config.path}': RouterPath('${step.config.name}', '${step.config.method.toLowerCase()}', route${index}_handler, route${index}_config)`)
-            .join(',\n    '));
-        archive.append(file, 'router.py');
-        (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archive);
-        // Finalize the archive and wait for completion
-        const size = await archive.finalize();
-        return { size, path: zipName };
+            .replace('# {{imports}}', imports)
+            .replace('# {{router paths}}', routerPaths);
     }
-    async getPythonBuilderData(step) {
-        return new Promise((resolve, reject) => {
-            const child = (0, child_process_1.spawn)('python', [path_1.default.join(__dirname, 'python-builder.py'), step.filePath], {
-                cwd: this.builder.projectDir,
-                stdio: [undefined, undefined, 'pipe', 'ipc'],
-            });
-            const err = [];
-            child.on('stderr', (data) => err.push(data.toString()));
-            child.on('message', resolve);
-            child.on('close', (code) => {
-                if (code !== 0) {
-                    reject(new Error(err.join('')));
+    async findInternalFiles(entryFile) {
+        const files = [];
+        const visited = new Set();
+        const analyzeFile = (filePath) => {
+            if (visited.has(filePath) || !fs_1.default.existsSync(filePath)) {
+                return;
+            }
+            visited.add(filePath);
+            files.push(path_1.default.relative(this.builder.projectDir, filePath));
+            try {
+                const content = fs_1.default.readFileSync(filePath, 'utf-8');
+                // Regex melhorada para capturar imports mais complexos
+                const importRegex = /^(?:from\s+([a-zA-Z_][a-zA-Z0-9_.]*)\s+import|import\s+([a-zA-Z_][a-zA-Z0-9_.]*))/gm;
+                let match;
+                while ((match = importRegex.exec(content)) !== null) {
+                    const moduleName = match[1] || match[2]; // from X import Y ou import X
+                    // Verificar diferentes formas de import
+                    this.resolveModulePaths(moduleName, path_1.default.dirname(filePath)).forEach(possiblePath => {
+                        if (fs_1.default.existsSync(possiblePath)) {
+                            analyzeFile(possiblePath);
+                        }
+                    });
                 }
-            });
-        });
+            }
+            catch (error) {
+                console.warn(`Could not analyze file: ${filePath}`);
+            }
+        };
+        analyzeFile(entryFile);
+        return files;
+    }
+    resolveModulePaths(moduleName, currentDir) {
+        const parts = moduleName.split('.');
+        const baseName = parts[0];
+        const subPath = parts.length > 1 ? path_1.default.join(...parts) : baseName;
+        return [
+            // Relativo ao arquivo atual
+            path_1.default.join(currentDir, `${baseName}.py`),
+            path_1.default.join(currentDir, baseName, '__init__.py'),
+            path_1.default.join(currentDir, `${subPath}.py`),
+            // Relativo ao diretório do projeto
+            path_1.default.join(this.builder.projectDir, `${baseName}.py`),
+            path_1.default.join(this.builder.projectDir, baseName, '__init__.py'),
+            path_1.default.join(this.builder.projectDir, `${subPath}.py`),
+            // Para utils.database -> utils/database.py
+            path_1.default.join(this.builder.projectDir, subPath + '.py'),
+            path_1.default.join(this.builder.projectDir, subPath, '__init__.py'),
+        ];
+    }
+    getModuleName(step) {
+        return this.normalizeStepPath(step, true)
+            .replace(/\.py$/, '')
+            .replace(/\//g, '.');
     }
 }
 exports.PythonBuilder = PythonBuilder;

package/dist/cjs/cloud/build/builders/python/uv-packager.d.ts

@@ -0,0 +1,14 @@
+export interface UvPackageConfig {
+    pythonVersion?: string;
+    platform?: string;
+    onlyBinary?: boolean;
+}
+export declare const defaultUvConfig: UvPackageConfig;
+export declare class UvPackager {
+    private readonly projectDir;
+    private readonly config;
+    constructor(projectDir: string, config?: UvPackageConfig);
+    checkUvInstalled(): Promise<boolean>;
+    packageDependencies(targetDir: string): Promise<void>;
+    private runUvCommand;
+}

package/dist/cjs/cloud/build/builders/python/uv-packager.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UvPackager = exports.defaultUvConfig = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.defaultUvConfig = {
+    pythonVersion: '3.13',
+    platform: 'x86_64-manylinux2014',
+    onlyBinary: true
+};
+class UvPackager {
+    constructor(projectDir, config = exports.defaultUvConfig) {
+        this.projectDir = projectDir;
+        this.config = config;
+    }
+    async checkUvInstalled() {
+        return new Promise((resolve) => {
+            const child = (0, child_process_1.spawn)('uv', ['--version'], { stdio: 'pipe' });
+            child.on('close', (code) => resolve(code === 0));
+            child.on('error', () => resolve(false));
+        });
+    }
+    async packageDependencies(targetDir) {
+        if (!fs_1.default.existsSync(targetDir)) {
+            fs_1.default.mkdirSync(targetDir, { recursive: true });
+        }
+        const requirementsFile = path_1.default.join(this.projectDir, 'requirements.txt');
+        if (!fs_1.default.existsSync(requirementsFile)) {
+            return;
+        }
+        const args = [
+            'pip', 'install',
+            '--target', targetDir,
+            '--requirement', requirementsFile,
+            '--python-version', this.config.pythonVersion || '3.13',
+            '--python-platform', this.config.platform || 'x86_64-manylinux2014',
+            '--force-reinstall'
+        ];
+        if (this.config.onlyBinary) {
+            args.push('--only-binary=:all:');
+        }
+        await this.runUvCommand(args);
+    }
+    async runUvCommand(args) {
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)('uv', args, {
+                cwd: this.projectDir,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve(stdout);
+                }
+                else {
+                    reject(new Error(`UV command failed: ${stderr || stdout}`));
+                }
+            });
+            child.on('error', (error) => {
+                reject(new Error(`Failed to spawn UV: ${error.message}`));
+            });
+        });
+    }
+}
+exports.UvPackager = UvPackager;

package/dist/cjs/dev.js

@@ -11,7 +11,6 @@ const analytics_node_1 = require("@amplitude/analytics-node");
 const generate_locked_data_1 = require("./generate-locked-data");
 const dev_watchers_1 = require("./dev-watchers");
 const state_endpoints_1 = require("./dev/state-endpoints");
-const endpoints_1 = require("./cloud/endpoints");
 const activate_python_env_1 = require("./utils/activate-python-env");
 const analytics_1 = require("./utils/analytics");
 const version_1 = require("./version");
@@ -56,7 +55,6 @@ const dev = async (port, hostname, disableVerbose, enableMermaid) => {
     }
     watcher.init();
     (0, state_endpoints_1.stateEndpoints)(motiaServer, state);
-    (0, endpoints_1.deployEndpoints)(motiaServer, lockedData);
     motiaServer.server.listen(port, hostname);
     console.log('🚀 Server ready and listening on port', port);
     console.log(`🔗 Open http://${hostname}:${port}/ to open workbench 🛠️`);

package/dist/cjs/utils/uv-install.d.ts

@@ -0,0 +1,6 @@
+export interface UvInstallConfig {
+    baseDir: string;
+    isVerbose?: boolean;
+    pythonVersion?: string;
+}
+export declare const uvInstall: ({ baseDir, isVerbose, pythonVersion }: UvInstallConfig) => Promise<void>;

package/dist/cjs/utils/uv-install.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uvInstall = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const colors_1 = __importDefault(require("colors"));
+const uvInstall = async ({ baseDir, isVerbose = false, pythonVersion = '3.13' }) => {
+    const projectDir = baseDir;
+    console.log('📦 Installing Python dependencies with UV...', projectDir);
+    try {
+        if (!await checkUvInstalled()) {
+            throw new Error('UV is not installed. Please install UV: curl -LsSf https://astral.sh/uv/install.sh | sh');
+        }
+        await ensureUvProject(projectDir, pythonVersion, isVerbose);
+        await installDependencies(projectDir, isVerbose);
+        console.log(colors_1.default.green('✅ Python dependencies installed successfully with UV'));
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error('❌ UV Installation failed:', errorMessage);
+        throw error;
+    }
+};
+exports.uvInstall = uvInstall;
+async function checkUvInstalled() {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)('uv', ['--version'], { stdio: 'pipe' });
+        child.on('close', (code) => {
+            resolve(code === 0);
+        });
+        child.on('error', () => {
+            resolve(false);
+        });
+    });
+}
+async function ensureUvProject(projectDir, pythonVersion, isVerbose) {
+    const pyprojectPath = path_1.default.join(projectDir, 'pyproject.toml');
+    if (!fs_1.default.existsSync(pyprojectPath)) {
+        if (isVerbose) {
+            console.log('📄 Creating pyproject.toml...');
+        }
+        await runUvCommand(['init', '--no-readme'], projectDir);
+        const pyprojectContent = generatePyprojectToml(pythonVersion);
+        fs_1.default.writeFileSync(pyprojectPath, pyprojectContent);
+    }
+    const pythonVersionFile = path_1.default.join(projectDir, '.python-version');
+    if (!fs_1.default.existsSync(pythonVersionFile)) {
+        fs_1.default.writeFileSync(pythonVersionFile, pythonVersion);
+    }
+}
+async function installDependencies(projectDir, isVerbose) {
+    const coreRequirementsPath = path_1.default.join(projectDir, 'node_modules', 'motia', 'dist', 'requirements-core.txt');
+    const snapRequirementsPath = path_1.default.join(projectDir, 'node_modules', 'motia', 'dist', 'requirements-snap.txt');
+    const localRequirements = path_1.default.join(projectDir, 'requirements.txt');
+    const requirementsList = [coreRequirementsPath, snapRequirementsPath, localRequirements];
+    for (const requirement of requirementsList) {
+        if (fs_1.default.existsSync(requirement)) {
+            if (isVerbose) {
+                console.log(`📄 Installing from: ${requirement}`);
+            }
+            try {
+                await runUvCommand(['add', '--requirements', requirement], projectDir);
+            }
+            catch (error) {
+                console.warn(colors_1.default.yellow(`Warning: Could not install some dependencies from ${requirement}`));
+                if (isVerbose) {
+                    console.warn(error);
+                }
+            }
+        }
+        else if (isVerbose) {
+            console.log(colors_1.default.yellow(`⚠️  Requirements file not found: ${requirement}`));
+        }
+    }
+    if (isVerbose) {
+        console.log('🔄 Syncing UV environment...');
+    }
+    await runUvCommand(['sync'], projectDir);
+}
+function generatePyprojectToml(pythonVersion) {
+    return `[project]
+name = "motia-project"
+version = "0.1.0"
+description = "Motia Python project"
+requires-python = ">=${pythonVersion}"
+dependencies = []
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv]
+dev-dependencies = []
+package = false
+
+[tool.uv.sources]
+`;
+}
+async function runUvCommand(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)('uv', args, {
+            cwd,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve(stdout);
+            }
+            else {
+                reject(new Error(`UV command failed: ${stderr || stdout}`));
+            }
+        });
+        child.on('error', (error) => {
+            reject(new Error(`Failed to spawn UV: ${error.message}`));
+        });
+    });
+}

package/dist/esm/cloud/build/builders/python/index.d.ts

@@ -4,9 +4,18 @@ import { BuildListener } from '../../../new-deployment/listeners/listener.types'
 export declare class PythonBuilder implements StepBuilder {
     private readonly builder;
     private readonly listener;
+    private uvPackager;
+    private uvConfig;
     constructor(builder: Builder, listener: BuildListener);
-    private buildStep;
-    build(step: Step): Promise<void>;
+    private loadUvConfig;
     buildApiSteps(steps: Step<ApiRouteConfig>[]): Promise<RouterBuildResult>;
-    private getPythonBuilderData;
+    build(step: Step): Promise<void>;
+    private addStepToArchive;
+    private addPackagesToArchive;
+    private shouldIgnoreFile;
+    private normalizeStepPath;
+    private createRouterTemplate;
+    private findInternalFiles;
+    private resolveModulePaths;
+    private getModuleName;
 }