motia 0.6.4-beta.131-595093 → 0.6.4-beta.131-211436

package/dist/cjs/cloud/build/builders/archiver.d.ts

@@ -8,6 +8,7 @@ export declare class Archiver {
     private readonly outputStream;
     private uncompressedSize;
     constructor(filePath: string);
+    appendDirectory(sourcePath: string, targetPath: string): void;
     append(stream: fs.ReadStream | string, filePath: string): void;
     finalize(): Promise<ArchiveResult>;
 }

package/dist/cjs/cloud/build/builders/archiver.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Archiver = void 0;
 const archiver_1 = __importDefault(require("archiver"));
 const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 class Archiver {
     constructor(filePath) {
         this.uncompressedSize = 0;
@@ -13,6 +14,29 @@ class Archiver {
         this.outputStream = fs_1.default.createWriteStream(filePath);
         this.archive.pipe(this.outputStream);
     }
+    appendDirectory(sourcePath, targetPath) {
+        try {
+            const items = fs_1.default.readdirSync(sourcePath);
+            for (const item of items) {
+                const fullPath = path_1.default.join(sourcePath, item);
+                try {
+                    const stat = fs_1.default.statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        this.appendDirectory(fullPath, path_1.default.join(targetPath, item));
+                    }
+                    else {
+                        this.append(fs_1.default.createReadStream(fullPath), targetPath ? path_1.default.join(targetPath, item) : item);
+                    }
+                }
+                catch (_error) {
+                    // Ignore individual file errors
+                }
+            }
+        }
+        catch (_error) {
+            // Ignore directory read errors
+        }
+    }
     append(stream, filePath) {
         // Track uncompressed size
         if (typeof stream === 'string') {

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

@@ -1,17 +1,16 @@
 import { ApiRouteConfig, Step } from '@motiadev/core';
-import { Builder, RouterBuildResult, StepBuilder } from '../../builder';
 import { BuildListener } from '../../../new-deployment/listeners/listener.types';
+import { Builder, RouterBuildResult, StepBuilder } from '../../builder';
 export declare class PythonBuilder implements StepBuilder {
     private readonly builder;
     private readonly listener;
-    private packageHandler;
+    private packager;
     constructor(builder: Builder, listener: BuildListener);
+    private getRequirements;
     buildApiSteps(steps: Step<ApiRouteConfig>[]): Promise<RouterBuildResult>;
     build(step: Step): Promise<void>;
-    private addStepToArchive;
-    private findInternalFiles;
-    private resolveModulePaths;
-    private normalizeStepPath;
+    private generatePackage;
+    private cleanup;
     private createRouterTemplate;
     private getModuleName;
 }

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

@@ -6,40 +6,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PythonBuilder = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const activate_python_env_1 = require("../../../../utils/activate-python-env");
+const constants_1 = require("../../../new-deployment/constants");
 const archiver_1 = require("../archiver");
 const include_static_files_1 = require("../include-static-files");
-const constants_1 = require("../../../new-deployment/constants");
-const activate_python_env_1 = require("../../../../utils/activate-python-env");
-const package_handler_1 = require("./package-handler");
+const extract_python_data_1 = require("./python-data/extract-python-data");
+const read_requirements_1 = require("./python-data/read-requirements");
+const resolve_dep_name_1 = require("./python-data/resolve-dep-name");
+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.packageHandler = new package_handler_1.PackageHandler(this.builder.projectDir);
+        this.packager = new uv_packager_1.UvPackager();
+    }
+    getRequirements() {
+        const requirementsFile = path_1.default.join(this.builder.projectDir, 'requirements.txt');
+        const depNames = Object.keys((0, read_requirements_1.readRequirements)(requirementsFile, (name) => ({ name, importName: name })));
+        const sitePackagesPath = (0, activate_python_env_1.getSitePackagesPath)({ baseDir: this.builder.projectDir });
+        const mapper = (0, resolve_dep_name_1.resolveDepNames)(depNames, sitePackagesPath);
+        const describer = (name) => {
+            const [, to] = mapper.find(([from]) => from === name) ?? [];
+            return { name, importName: to ?? name };
+        };
+        return (0, read_requirements_1.readRequirements)(requirementsFile, describer);
     }
     async buildApiSteps(steps) {
         const zipName = 'router-python.zip';
         const archive = new archiver_1.Archiver(path_1.default.join(constants_1.distDir, zipName));
-        let tempDirToCleanup;
+        const bundleDir = path_1.default.join(constants_1.distDir, 'python', 'router');
         try {
-            // Collect all Python files for analysis
-            const pythonFiles = steps.map((step) => step.filePath);
-            // Build packages using the unified handler
-            const buildResult = await this.packageHandler.buildPackages({
-                pythonFiles,
-                archive,
-                projectDir: this.builder.projectDir,
-            });
-            tempDirToCleanup = buildResult.tempDirCreated;
-            // Add all step files to archive
-            for (const step of steps) {
-                await this.addStepToArchive(step, archive);
-            }
-            // Add router template
+            fs_1.default.mkdirSync(bundleDir, { recursive: true });
             const routerTemplate = this.createRouterTemplate(steps);
             archive.append(routerTemplate, 'router.py');
-            // Include static files
+            await this.generatePackage(bundleDir, 'router.py', archive, routerTemplate);
             (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archive);
             const { compressedSize, uncompressedSize } = await archive.finalize();
             return { compressedSize, uncompressedSize, path: zipName };
@@ -48,34 +49,21 @@ class PythonBuilder {
             throw new Error(`Failed to build Python API router: ${error}`);
         }
         finally {
-            this.packageHandler.cleanup(tempDirToCleanup);
+            this.cleanup(bundleDir);
         }
     }
     async build(step) {
-        const entrypointPath = step.filePath.replace(this.builder.projectDir, '').replace(/\.step\.py$/, '_step.py');
+        const entrypointPath = step.filePath.replace(this.builder.projectDir, '');
         const bundlePath = path_1.default.join('python', entrypointPath.replace(/(.*)\.py$/, '$1.zip'));
+        const bundleDir = path_1.default.join(constants_1.distDir, 'python', entrypointPath.replace(/(.*)\.py$/, '$1'));
         const outfile = path_1.default.join(constants_1.distDir, bundlePath);
         this.builder.registerStep({ entrypointPath, bundlePath, step, type: 'python' });
         this.listener.onBuildStart(step);
-        let tempDirToCleanup;
         try {
             fs_1.default.mkdirSync(path_1.default.dirname(outfile), { recursive: true });
+            fs_1.default.mkdirSync(bundleDir, { recursive: true });
             const archive = new archiver_1.Archiver(outfile);
-            // Collect Python files for analysis (including internal files)
-            const pythonFiles = [step.filePath];
-            const internalFiles = await this.findInternalFiles(step.filePath);
-            for (const file of internalFiles) {
-                pythonFiles.push(path_1.default.join(this.builder.projectDir, file));
-            }
-            // Build packages using the unified handler
-            const buildResult = await this.packageHandler.buildPackages({
-                pythonFiles,
-                archive,
-                projectDir: this.builder.projectDir,
-            });
-            tempDirToCleanup = buildResult.tempDirCreated;
-            // Add step file to archive
-            await this.addStepToArchive(step, archive);
+            await this.generatePackage(bundleDir, entrypointPath, archive);
             // Include static files
             (0, include_static_files_1.includeStaticFiles)([step], this.builder, archive);
             const { compressedSize, uncompressedSize } = await archive.finalize();
@@ -87,93 +75,60 @@ class PythonBuilder {
             throw err;
         }
         finally {
-            this.packageHandler.cleanup(tempDirToCleanup);
+            this.cleanup(bundleDir);
         }
     }
-    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 generatePackage(bundleDir, entrypointPath, archive, fileContent) {
+        const requirements = this.getRequirements();
+        const { externalDependencies, files } = (0, extract_python_data_1.extractPythonData)(this.builder.projectDir, entrypointPath, requirements, fileContent);
+        // move files
+        for (const file of files) {
+            fs_1.default.mkdirSync(path_1.default.dirname(path_1.default.join(bundleDir, file)), { recursive: true });
+            if (fileContent && file === entrypointPath) {
+                fs_1.default.writeFileSync(path_1.default.join(bundleDir, file), fileContent);
             }
+            else {
+                fs_1.default.copyFileSync(path_1.default.join(this.builder.projectDir, file), path_1.default.join(bundleDir, file));
+            }
+        }
+        const dependencies = Object.values(externalDependencies);
+        if (dependencies.length > 0) {
+            // create requirements.txt
+            fs_1.default.writeFileSync(path_1.default.join(bundleDir, 'requirements.txt'), Object.values(externalDependencies).join('\n'));
+            await this.packager.packageDependencies(bundleDir);
         }
+        // zip entire folder
+        archive.appendDirectory(bundleDir, '/');
     }
-    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));
+    cleanup(bundleDir) {
+        if (bundleDir && fs_1.default.existsSync(bundleDir)) {
             try {
-                const content = fs_1.default.readFileSync(filePath, 'utf-8');
-                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];
-                    this.resolveModulePaths(moduleName, path_1.default.dirname(filePath)).forEach((possiblePath) => {
-                        if (fs_1.default.existsSync(possiblePath)) {
-                            analyzeFile(possiblePath);
-                        }
-                    });
-                }
+                fs_1.default.rmSync(bundleDir, { recursive: true, force: true });
             }
             catch (_error) {
-                // Ignore file read/parse errors
+                // Ignore cleanup errors
             }
-        };
-        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 [
-            path_1.default.join(currentDir, `${baseName}.py`),
-            path_1.default.join(currentDir, baseName, '__init__.py'),
-            path_1.default.join(currentDir, `${subPath}.py`),
-            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`),
-            path_1.default.join(this.builder.projectDir, subPath + '.py'),
-            path_1.default.join(this.builder.projectDir, subPath, '__init__.py'),
-        ];
-    }
-    normalizeStepPath(step, normalizePythonModulePath) {
-        let normalizedStepPath = step.filePath.replace(/[.]step.py$/, '_step.py').replace(`${this.builder.projectDir}/`, '');
-        const pathParts = normalizedStepPath.split(path_1.default.sep).map((part) => part
-            .replace(/[^a-zA-Z0-9._]/g, '_') // Replace any non-alphanumeric characters (except dots) with underscores
-            .replace(/^_/, ''));
-        normalizedStepPath = normalizePythonModulePath ? pathParts.join('.') : '/' + pathParts.join(path_1.default.sep);
-        return normalizedStepPath;
+        }
     }
     createRouterTemplate(steps) {
         const imports = steps
-            .map((step, index) => {
-            const moduleName = this.getModuleName(step);
-            return `route${index}_module = importlib.import_module('${moduleName}')`;
-        })
+            .map((step, index) => `from ${this.getModuleName(step)} 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}_module.handler, route${index}_module.config)`;
+            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}}', imports)
-            .replace('# {{router paths}}', routerPaths);
+            .replace('    # {{router paths}}', routerPaths);
     }
     getModuleName(step) {
-        return this.normalizeStepPath(step, true).replace(/\.py$/, '').replace(/\//g, '.');
+        // return step path
+        return step.filePath.replace(this.builder.projectDir, '').substring(1).replace(/\.py$/, '').replace(/\//g, '.');
     }
 }
 exports.PythonBuilder = PythonBuilder;

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/convert-import-path.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/convert-import-path.test.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const convert_import_path_1 = require("../convert-import-path");
+describe('convertImportToPath', () => {
+    test('converts regular module imports', () => {
+        // Regular module imports
+        expect((0, convert_import_path_1.convertImportToPath)('mymodule')).toBe('mymodule');
+        expect((0, convert_import_path_1.convertImportToPath)('mymodule.submodule')).toBe('mymodule/submodule');
+        expect((0, convert_import_path_1.convertImportToPath)('package.module.submodule')).toBe('package/module/submodule');
+    });
+    test('converts relative imports', () => {
+        // Relative imports
+        expect((0, convert_import_path_1.convertImportToPath)('.module')).toBe('module');
+        expect((0, convert_import_path_1.convertImportToPath)('..module')).toBe('../module');
+        expect((0, convert_import_path_1.convertImportToPath)('...module')).toBe('../../module');
+        expect((0, convert_import_path_1.convertImportToPath)('..utils.database')).toBe('../utils/database');
+    });
+    test('handles edge cases', () => {
+        // Edge cases
+        expect((0, convert_import_path_1.convertImportToPath)('.')).toBe('.');
+        expect((0, convert_import_path_1.convertImportToPath)('..')).toBe('..');
+        expect((0, convert_import_path_1.convertImportToPath)('...')).toBe('../..');
+    });
+});

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/extract-python-data.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/extract-python-data.test.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const glob_1 = require("glob");
+const read_requirements_1 = require("../read-requirements");
+const extract_python_data_1 = require("../extract-python-data");
+const python_errors_1 = require("../python-errors");
+const mockPackageDescriber = (name) => ({ name, importName: name });
+describe('extractPythonData', () => {
+    test('extracts python data correctly', () => {
+        const rootDir = path_1.default.join(__dirname, './examples/example-1');
+        const requirements = (0, read_requirements_1.readRequirements)(path_1.default.join(rootDir, 'requirements.txt'), mockPackageDescriber);
+        const steps = (0, glob_1.globSync)('**/*_step.py', { absolute: false, cwd: path_1.default.join(rootDir, 'steps') });
+        for (const file of steps) {
+            const result = (0, extract_python_data_1.extractPythonData)(rootDir, `/steps/${file}`, requirements);
+            expect(result).toEqual({
+                standardLibDependencies: ['typing', 'enum'],
+                externalDependencies: { httpx: 'httpx>=0.28.1', pydantic: 'pydantic>=2.6.1' },
+                files: ['/steps/api_step.py', '/src/__init__.py', '/src/pet_store.py', '/src/types.py'],
+            });
+        }
+    });
+    test('extracts python data correctly with invalid dependency', () => {
+        const rootDir = path_1.default.join(__dirname, './examples/invalid-dependency');
+        const requirements = (0, read_requirements_1.readRequirements)(path_1.default.join(rootDir, 'requirements.txt'), mockPackageDescriber);
+        expect(() => (0, extract_python_data_1.extractPythonData)(rootDir, `/steps/api_step.py`, requirements)).toThrow(python_errors_1.PythonImportNotFoundError);
+    });
+    test('extracts python data correctly with compilation error', () => {
+        const rootDir = path_1.default.join(__dirname, './examples/compilation-error');
+        const requirements = (0, read_requirements_1.readRequirements)(path_1.default.join(rootDir, 'requirements.txt'), mockPackageDescriber);
+        expect(() => (0, extract_python_data_1.extractPythonData)(rootDir, `/steps/api_step.py`, requirements)).toThrow(new python_errors_1.PythonError("Compilation error: no viable alternative at input ':' at line 3:10 in /steps/api_step.py", '/steps/api_step.py'));
+    });
+});

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/get-dependencies-from-file.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/get-dependencies-from-file.test.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_dependencies_from_file_1 = require("../get-dependencies-from-file");
+describe('getDependenciesFromFile', () => {
+    test('categorizes dependencies correctly', () => {
+        const pythonCode = `
+import os
+import sys
+from collections import defaultdict
+import requests
+from .local_module import something
+from ..parent_module import other
+`;
+        const requirements = {
+            requests: 'requests==2.25.1',
+        };
+        const deps = (0, get_dependencies_from_file_1.getDependenciesFromFile)(pythonCode, 'test.py', requirements);
+        expect(Array.from(deps.standardLibDependencies)).toEqual(['os', 'sys', 'collections']);
+        expect(Array.from(deps.externalDependencies)).toEqual(['requests']);
+        expect(Array.from(deps.projectDependencies)).toEqual(['.local_module', '..parent_module']);
+    });
+    test('handles relative imports correctly', () => {
+        const pythonCode = 'from ...utils.database import connect';
+        const requirements = {};
+        const deps = (0, get_dependencies_from_file_1.getDependenciesFromFile)(pythonCode, 'test.py', requirements);
+        expect(Array.from(deps.projectDependencies)).toEqual(['...utils.database']);
+    });
+    test('handles import statements with requirements dep', () => {
+        const pythonCode = `
+import json
+import numpy 
+import mypackage.submodule
+`;
+        const requirements = {
+            numpy: 'numpy==1.21.0',
+        };
+        const deps = (0, get_dependencies_from_file_1.getDependenciesFromFile)(pythonCode, 'test.py', requirements);
+        expect(Array.from(deps.standardLibDependencies)).toEqual(['json']);
+        expect(Array.from(deps.externalDependencies)).toEqual(['numpy']);
+        expect(Array.from(deps.projectDependencies)).toEqual(['mypackage.submodule']);
+    });
+    test('handles import statements with requirements dep and alias', () => {
+        const pythonCode = `
+import json
+import numpy as np
+import mypackage.submodule
+`;
+        const requirements = {
+            numpy: 'numpy==1.21.0',
+        };
+        const deps = (0, get_dependencies_from_file_1.getDependenciesFromFile)(pythonCode, 'test.py', requirements);
+        expect(Array.from(deps.standardLibDependencies)).toEqual(['json']);
+        expect(Array.from(deps.externalDependencies)).toEqual(['numpy']);
+        expect(Array.from(deps.projectDependencies)).toEqual(['mypackage.submodule']);
+    });
+    test('handles empty file', () => {
+        const pythonCode = '';
+        const requirements = {};
+        const deps = (0, get_dependencies_from_file_1.getDependenciesFromFile)(pythonCode, 'test.py', requirements);
+        expect(deps.standardLibDependencies.size).toBe(0);
+        expect(deps.externalDependencies.size).toBe(0);
+        expect(deps.projectDependencies.size).toBe(0);
+    });
+    test('handles unknown external dependencies as project dependencies', () => {
+        const pythonCode = 'import unknown_package';
+        const requirements = {};
+        const deps = (0, get_dependencies_from_file_1.getDependenciesFromFile)(pythonCode, 'test.py', requirements);
+        expect(Array.from(deps.projectDependencies)).toEqual(['unknown_package']);
+    });
+});

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/read-requirements.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/read-requirements.test.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const read_requirements_1 = require("../read-requirements");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = require("os");
+describe('readRequirements', () => {
+    let tempFilePath;
+    const mockPackageDescriber = jest.fn((name) => ({ name, importName: name }));
+    beforeEach(() => {
+        // Create a temporary file path
+        tempFilePath = path_1.default.join((0, os_1.tmpdir)(), `requirements-${Date.now()}.txt`);
+    });
+    afterEach(() => {
+        // Clean up temporary file if it exists
+        if (fs_1.default.existsSync(tempFilePath)) {
+            fs_1.default.unlinkSync(tempFilePath);
+        }
+    });
+    test('reads basic requirements correctly', () => {
+        const content = `requests==2.25.1
+numpy>=1.20.0
+flask~=2.0`;
+        fs_1.default.writeFileSync(tempFilePath, content);
+        const requirements = (0, read_requirements_1.readRequirements)(tempFilePath, mockPackageDescriber);
+        expect(Object.keys(requirements)).toHaveLength(3);
+        expect(requirements.requests).toBe('requests==2.25.1');
+        expect(requirements.numpy).toBe('numpy>=1.20.0');
+        expect(requirements.flask).toBe('flask~=2.0');
+    });
+    test('skips comments and empty lines', () => {
+        const content = `# This is a comment
+requests==2.25.1
+
+# Another comment
+numpy>=1.20.0
+
+flask~=2.0`;
+        fs_1.default.writeFileSync(tempFilePath, content);
+        const requirements = (0, read_requirements_1.readRequirements)(tempFilePath, mockPackageDescriber);
+        expect(Object.keys(requirements)).toHaveLength(3);
+        expect(requirements.requests).toBe('requests==2.25.1');
+        expect(requirements.numpy).toBe('numpy>=1.20.0');
+        expect(requirements.flask).toBe('flask~=2.0');
+    });
+    test('handles complex package names and version specifiers', () => {
+        const content = `scikit-learn==1.0.2
+python-dateutil==1.4
+Django<4.0.0,>=3.2.0`;
+        fs_1.default.writeFileSync(tempFilePath, content);
+        const describer = jest.fn((name) => {
+            // mocking a describer resolution for these packages
+            // we're going to implement it separately
+            const map = {
+                'scikit-learn': 'sklearn',
+                'python-dateutil': 'dateutil',
+                Django: 'django',
+            };
+            return map[name] ? { name, importName: map[name] } : { name, importName: name };
+        });
+        const requirements = (0, read_requirements_1.readRequirements)(tempFilePath, describer);
+        expect(Object.keys(requirements)).toEqual(['sklearn', 'dateutil', 'django']);
+        expect(requirements['sklearn']).toBe('scikit-learn==1.0.2');
+        expect(requirements['dateutil']).toBe('python-dateutil==1.4');
+        expect(requirements['django']).toBe('Django<4.0.0,>=3.2.0');
+    });
+    test('handles requirements with extra dependencies', () => {
+        const content = `requests[security]==2.25.1
+flask[async]==2.0.1`;
+        fs_1.default.writeFileSync(tempFilePath, content);
+        const requirements = (0, read_requirements_1.readRequirements)(tempFilePath, mockPackageDescriber);
+        expect(Object.keys(requirements)).toHaveLength(2);
+        expect(requirements['requests']).toBe('requests[security]==2.25.1');
+        expect(requirements['flask']).toBe('flask[async]==2.0.1');
+    });
+    test('handles empty requirements file', () => {
+        const content = `# Only comments
+
+# And empty lines`;
+        fs_1.default.writeFileSync(tempFilePath, content);
+        const requirements = (0, read_requirements_1.readRequirements)(tempFilePath, mockPackageDescriber);
+        expect(Object.keys(requirements)).toHaveLength(0);
+    });
+    test('handles malformed lines gracefully', () => {
+        const content = `requests==2.25.1
+# Valid package
+numpy>=1.20.0
+==invalid-version-only`;
+        fs_1.default.writeFileSync(tempFilePath, content);
+        const requirements = (0, read_requirements_1.readRequirements)(tempFilePath, mockPackageDescriber);
+        expect(Object.keys(requirements)).toHaveLength(2);
+        expect(requirements.requests).toBe('requests==2.25.1');
+        expect(requirements.numpy).toBe('numpy>=1.20.0');
+    });
+    test('handles mixed line endings', () => {
+        const content = 'requests==2.25.1\r\nnumpy>=1.20.0\nflask~=2.0';
+        fs_1.default.writeFileSync(tempFilePath, content);
+        const requirements = (0, read_requirements_1.readRequirements)(tempFilePath, mockPackageDescriber);
+        expect(Object.keys(requirements)).toHaveLength(3);
+        expect(requirements.requests).toBe('requests==2.25.1');
+        expect(requirements.numpy).toBe('numpy>=1.20.0');
+        expect(requirements.flask).toBe('flask~=2.0');
+    });
+    test('handles requirements with no versions', () => {
+        const content = ['requests', 'numpy', 'flask'].join('\n');
+        fs_1.default.writeFileSync(tempFilePath, content);
+        const requirements = (0, read_requirements_1.readRequirements)(tempFilePath, mockPackageDescriber);
+        expect(Object.keys(requirements)).toHaveLength(3);
+        expect(requirements.requests).toBe('requests');
+        expect(requirements.numpy).toBe('numpy');
+        expect(requirements.flask).toBe('flask');
+    });
+});

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/resolve-dep-name.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/cloud/build/builders/python/python-data/__tests__/resolve-dep-name.test.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const resolve_dep_name_1 = require("../resolve-dep-name");
+const python_errors_1 = require("../python-errors");
+const sitePackagesDir = path_1.default.join(__dirname, 'site-packages');
+describe('resolveDepName', () => {
+    test('resolves dependency names correctly', () => {
+        const depNames = ['httpx'];
+        const result = (0, resolve_dep_name_1.resolveDepNames)(depNames, sitePackagesDir);
+        expect(result).toEqual([['httpx', 'httpx']]);
+    });
+    test('resolves multiple dependency names correctly', () => {
+        const depNames = ['httpx', 'scikit-learn', 'opencv-python'];
+        const result = (0, resolve_dep_name_1.resolveDepNames)(depNames, sitePackagesDir);
+        expect(result).toEqual([
+            ['httpx', 'httpx'],
+            ['scikit-learn', 'sklearn'],
+            ['opencv-python', 'cv2'],
+        ]);
+    });
+    test('should throw an error if the dependency is not found', () => {
+        const depNames = ['httpx', 'scikit-learn', 'opencv-python', 'pydantic'];
+        expect(() => (0, resolve_dep_name_1.resolveDepNames)(depNames, sitePackagesDir)).toThrow(new python_errors_1.PythonError('Could not find dependency name in site-packages: pydantic', 'pydantic'));
+    });
+});

package/dist/cjs/cloud/build/builders/python/python-data/constants.d.ts

@@ -0,0 +1 @@
+export declare const STANDARD_LIB_MODULES: Set<string>;