feat: support uv-managed projects

Author: Jeff Gordon

.github/workflows/validate.yml

@@ -63,14 +63,17 @@ jobs:
       - name: Install pipenv / poetry
         run: python -m pip install pipenv poetry
 
-      - name: Install serverless
-        run: npm install -g serverless@${{ matrix.sls-version }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
 
       - name: Install dependencies
         if: steps.cacheNpm.outputs.cache-hit != 'true'
         run: |
           npm update --no-save
           npm update --save-dev --no-save
+      - name: Install serverless
+        run: npm install serverless@${{ matrix.sls-version }}
+
       - name: Validate Prettier formatting
         run: npm run prettier-check:updated
       - name: Validate ESLint rules

.gitignore

@@ -49,6 +49,7 @@ yarn.lock
 
 # Lockfiles
 *.lock
+!uv.lock
 
 # Distribution / packaging
 .Python

README.md

@@ -150,6 +150,17 @@ custom:
       - lambda_dependencies
 ```
 
+## :sparkles::rocket::sparkles: uv support
+
+If you include a `uv.lock` and have `uv` installed, this will use `uv` to generate requirements instead of a `requirements.txt`. It is fully compatible with all options such as `zip` and
+`dockerizePip`. If you don't want this plugin to generate it for you, set the following option:
+
+```yaml
+custom:
+  pythonRequirements:
+    useUv: false
+```
+
 ### Poetry with git dependencies
 
 Poetry by default generates the exported requirements.txt file with `-e` and that breaks pip with `-t` parameter

index.js

@@ -13,6 +13,7 @@ const { injectAllRequirements } = require('./lib/inject');
 const { layerRequirements } = require('./lib/layer');
 const { installAllRequirements } = require('./lib/pip');
 const { pipfileToRequirements } = require('./lib/pipenv');
+const { uvToRequirements } = require('./lib/uv');
 const { cleanup, cleanupCache } = require('./lib/clean');
 BbPromise.promisifyAll(fse);
 
@@ -37,6 +38,7 @@ class ServerlessPythonRequirements {
         fileName: 'requirements.txt',
         usePipenv: true,
         usePoetry: true,
+        useUv: true,
         pythonBin:
           process.platform === 'win32'
             ? 'python.exe'
@@ -226,6 +228,7 @@ class ServerlessPythonRequirements {
       }
       return BbPromise.bind(this)
         .then(pipfileToRequirements)
+        .then(uvToRequirements)
         .then(addVendorHelper)
         .then(installAllRequirements)
         .then(packRequirements)

lib/pip.js

@@ -86,6 +86,22 @@ function generateRequirementsFile(
         `Parsed requirements.txt from Pipfile in ${targetFile}...`
       );
     }
+  } else if (
+    options.useUv &&
+    fse.existsSync(path.join(servicePath, 'uv.lock'))
+  ) {
+    filterRequirementsFile(
+      path.join(servicePath, '.serverless/requirements.txt'),
+      targetFile,
+      pluginInstance
+    );
+    if (log) {
+      log.info(`Parsed requirements.txt from uv.lock in ${targetFile}`);
+    } else {
+      serverless.cli.log(
+        `Parsed requirements.txt from uv.lock in ${targetFile}...`
+      );
+    }
   } else {
     filterRequirementsFile(requirementsPath, targetFile, pluginInstance);
     if (log) {
@@ -591,6 +607,10 @@ function requirementsFileExists(servicePath, options, fileName) {
     return true;
   }
 
+  if (options.useUv && fse.existsSync(path.join(servicePath, 'uv.lock'))) {
+    return true;
+  }
+
   if (fse.existsSync(fileName)) {
     return true;
   }

lib/uv.js

@@ -0,0 +1,104 @@
+const fse = require('fs-extra');
+const path = require('path');
+const spawn = require('child-process-ext/spawn');
+const { EOL } = require('os');
+const semver = require('semver');
+
+async function getUvVersion() {
+  try {
+    const res = await spawn('uv', ['--version'], {
+      cwd: this.servicePath,
+    });
+
+    const stdoutBuffer =
+      (res.stdoutBuffer && res.stdoutBuffer.toString().trim()) || '';
+
+    const version = stdoutBuffer.split(' ')[1];
+
+    if (semver.valid(version)) {
+      return version;
+    } else {
+      throw new this.serverless.classes.Error(
+        `Unable to parse uv version!`,
+        'PYTHON_REQUIREMENTS_UV_VERSION_ERROR'
+      );
+    }
+  } catch (e) {
+    const stderrBufferContent =
+      (e.stderrBuffer && e.stderrBuffer.toString()) || '';
+
+    if (stderrBufferContent.includes('command not found')) {
+      throw new this.serverless.classes.Error(
+        `uv not found! Install it according to the uv docs.`,
+        'PYTHON_REQUIREMENTS_UV_NOT_FOUND'
+      );
+    } else {
+      throw e;
+    }
+  }
+}
+
+/**
+ * uv to requirements.txt
+ */
+async function uvToRequirements() {
+  if (
+    !this.options.useUv ||
+    !fse.existsSync(path.join(this.servicePath, 'uv.lock'))
+  ) {
+    return;
+  }
+
+  let generateRequirementsProgress;
+  if (this.progress && this.log) {
+    generateRequirementsProgress = this.progress.get(
+      'python-generate-requirements-uv'
+    );
+    generateRequirementsProgress.update(
+      'Generating requirements.txt from uv.lock'
+    );
+    this.log.info('Generating requirements.txt from uv.lock');
+  } else {
+    this.serverless.cli.log('Generating requirements.txt from uv.lock...');
+  }
+
+  let res;
+
+  try {
+    await getUvVersion();
+    res = await spawn('uv', ['export', '--no-dev', '--frozen', '--no-hashes'], {
+      cwd: this.servicePath,
+    });
+
+    fse.ensureDirSync(path.join(this.servicePath, '.serverless'));
+    fse.writeFileSync(
+      path.join(this.servicePath, '.serverless/requirements.txt'),
+      removeEditableFlagFromRequirementsString(res.stdoutBuffer)
+    );
+  } finally {
+    generateRequirementsProgress && generateRequirementsProgress.remove();
+  }
+}
+
+/**
+ *
+ * @param requirementBuffer
+ * @returns Buffer with editable flags remove
+ */
+function removeEditableFlagFromRequirementsString(requirementBuffer) {
+  const flagStr = '-e ';
+  const commentLine = '#';
+  const lines = requirementBuffer.toString('utf8').split(EOL);
+  const newLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith(flagStr)) {
+      newLines.push(lines[i].substring(flagStr.length));
+    }
+    if (lines[i].startsWith(commentLine)) {
+      continue;
+    }
+  }
+  return Buffer.from(newLines.join(EOL));
+}
+
+module.exports = { uvToRequirements };

test.js

@@ -615,6 +615,98 @@ test("pipenv py3.9 doesn't package bottle with noDeploy option", async (t) => {
   t.end();
 });
 
+test('uv py3.9 can package flask with default options', async (t) => {
+  process.chdir('tests/uv');
+  const { stdout: path } = npm(['pack', '../..']);
+  npm(['i', path]);
+  sls(['package'], { env: {} });
+  const zipfiles = await listZipFiles('.serverless/sls-py-req-test.zip');
+  t.true(zipfiles.includes(`flask${sep}__init__.py`), 'flask is packaged');
+  t.true(zipfiles.includes(`boto3${sep}__init__.py`), 'boto3 is packaged');
+  t.false(
+    zipfiles.includes(`pytest${sep}__init__.py`),
+    'dev-package pytest is NOT packaged'
+  );
+  t.end();
+});
+
+test('uv py3.9 can package flask with slim option', async (t) => {
+  process.chdir('tests/uv');
+  const { stdout: path } = npm(['pack', '../..']);
+  npm(['i', path]);
+  sls(['package'], { env: { slim: 'true' } });
+  const zipfiles = await listZipFiles('.serverless/sls-py-req-test.zip');
+  t.true(zipfiles.includes(`flask${sep}__init__.py`), 'flask is packaged');
+  t.deepEqual(
+    zipfiles.filter((filename) => filename.endsWith('.pyc')),
+    [],
+    'no pyc files packaged'
+  );
+  t.true(
+    zipfiles.filter((filename) => filename.endsWith('__main__.py')).length > 0,
+    '__main__.py files are packaged'
+  );
+  t.end();
+});
+
+test('uv py3.9 can package flask with slim & slimPatterns options', async (t) => {
+  process.chdir('tests/uv');
+
+  copySync('_slimPatterns.yml', 'slimPatterns.yml');
+  const { stdout: path } = npm(['pack', '../..']);
+  npm(['i', path]);
+  sls(['package'], { env: { slim: 'true' } });
+  const zipfiles = await listZipFiles('.serverless/sls-py-req-test.zip');
+  t.true(zipfiles.includes(`flask${sep}__init__.py`), 'flask is packaged');
+  t.deepEqual(
+    zipfiles.filter((filename) => filename.endsWith('.pyc')),
+    [],
+    'no pyc files packaged'
+  );
+  t.deepEqual(
+    zipfiles.filter((filename) => filename.endsWith('__main__.py')),
+    [],
+    '__main__.py files are NOT packaged'
+  );
+  t.end();
+});
+
+test('uv py3.9 can package flask with zip option', async (t) => {
+  process.chdir('tests/uv');
+  const { stdout: path } = npm(['pack', '../..']);
+  npm(['i', path]);
+  sls(['package'], { env: { zip: 'true', pythonBin: getPythonBin(3) } });
+  const zipfiles = await listZipFiles('.serverless/sls-py-req-test.zip');
+  t.true(
+    zipfiles.includes('.requirements.zip'),
+    'zipped requirements are packaged'
+  );
+  t.true(zipfiles.includes(`unzip_requirements.py`), 'unzip util is packaged');
+  t.false(
+    zipfiles.includes(`flask${sep}__init__.py`),
+    "flask isn't packaged on its own"
+  );
+  t.end();
+});
+
+test("uv py3.9 doesn't package bottle with noDeploy option", async (t) => {
+  process.chdir('tests/uv');
+  const { stdout: path } = npm(['pack', '../..']);
+  npm(['i', path]);
+  perl([
+    '-p',
+    '-i.bak',
+    '-e',
+    's/(pythonRequirements:$)/\\1\\n    noDeploy: [bottle]/',
+    'serverless.yml',
+  ]);
+  sls(['package'], { env: {} });
+  const zipfiles = await listZipFiles('.serverless/sls-py-req-test.zip');
+  t.true(zipfiles.includes(`flask${sep}__init__.py`), 'flask is packaged');
+  t.false(zipfiles.includes(`bottle.py`), 'bottle is NOT packaged');
+  t.end();
+});
+
 test('non build pyproject.toml uses requirements.txt', async (t) => {
   process.chdir('tests/non_build_pyproject');
   const { stdout: path } = npm(['pack', '../..']);
@@ -963,6 +1055,29 @@ test('pipenv py3.9 can package flask with slim & slimPatterns & slimPatternsAppe
   t.end();
 });
 
+test('uv py3.9 can package flask with slim & slimPatterns & slimPatternsAppendDefaults=false  option', async (t) => {
+  process.chdir('tests/uv');
+  copySync('_slimPatterns.yml', 'slimPatterns.yml');
+  const { stdout: path } = npm(['pack', '../..']);
+  npm(['i', path]);
+
+  sls(['package'], {
+    env: { slim: 'true', slimPatternsAppendDefaults: 'false' },
+  });
+  const zipfiles = await listZipFiles('.serverless/sls-py-req-test.zip');
+  t.true(zipfiles.includes(`flask${sep}__init__.py`), 'flask is packaged');
+  t.true(
+    zipfiles.filter((filename) => filename.endsWith('.pyc')).length >= 1,
+    'pyc files are packaged'
+  );
+  t.deepEqual(
+    zipfiles.filter((filename) => filename.endsWith('__main__.py')),
+    [],
+    '__main__.py files are NOT packaged'
+  );
+  t.end();
+});
+
 test('poetry py3.9 can package flask with slim & slimPatterns & slimPatternsAppendDefaults=false  option', async (t) => {
   process.chdir('tests/poetry');
   copySync('_slimPatterns.yml', 'slimPatterns.yml');

tests/base/package.json

@@ -9,6 +9,6 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "serverless-python-requirements": "file:serverless-python-requirements-6.0.1.tgz"
+    "serverless-python-requirements": "file:serverless-python-requirements-6.1.1.tgz"
   }
 }

tests/non_build_pyproject/package.json

@@ -9,6 +9,6 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "serverless-python-requirements": "file:serverless-python-requirements-6.0.1.tgz"
+    "serverless-python-requirements": "file:serverless-python-requirements-6.1.1.tgz"
   }
 }

tests/non_poetry_pyproject/package.json

@@ -9,6 +9,6 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "serverless-python-requirements": "file:serverless-python-requirements-6.0.1.tgz"
+    "serverless-python-requirements": "file:serverless-python-requirements-6.1.1.tgz"
   }
 }