infra: migrate to uv (#29566)

.github/scripts/check_diff.py

@@ -7,6 +7,8 @@ from typing import Dict, List, Set
 from pathlib import Path
 import tomllib
 
+from packaging.requirements import Requirement
+
 from get_min_versions import get_min_version_from_toml
 
 
@@ -37,6 +39,8 @@ IGNORED_PARTNERS = [
 
 PY_312_MAX_PACKAGES = [
     "libs/partners/huggingface",  # https://github.com/pytorch/pytorch/issues/130249
+    "libs/partners/pinecone",
+    "libs/partners/voyageai",
 ]
 
 
@@ -61,15 +65,17 @@ def dependents_graph() -> dict:
 
         # load regular and test deps from pyproject.toml
         with open(path, "rb") as f:
-            pyproject = tomllib.load(f)["tool"]["poetry"]
+            pyproject = tomllib.load(f)
 
         pkg_dir = "libs" + "/".join(path.split("libs")[1].split("/")[:-1])
         for dep in [
-            *pyproject["dependencies"].keys(),
-            *pyproject["group"]["test"]["dependencies"].keys(),
+            *pyproject["project"]["dependencies"],
+            *pyproject["dependency-groups"]["test"],
         ]:
+            requirement = Requirement(dep)
+            package_name = requirement.name
             if "langchain" in dep:
-                dependents[dep].add(pkg_dir)
+                dependents[package_name].add(pkg_dir)
                 continue
 
         # load extended deps from extended_testing_deps.txt
@@ -120,8 +126,7 @@ def _get_configs_for_single_dir(job: str, dir_: str) -> List[Dict[str, str]]:
         py_versions = ["3.9", "3.10", "3.11", "3.12", "3.13"]
     # custom logic for specific directories
     elif dir_ == "libs/partners/milvus":
-        # milvus poetry doesn't allow 3.12 because they
-        # declare deps in funny way
+        # milvus doesn't allow 3.12 because they declare deps in funny way
         py_versions = ["3.9", "3.11"]
 
     elif dir_ in PY_312_MAX_PACKAGES:
@@ -148,17 +153,17 @@ def _get_configs_for_single_dir(job: str, dir_: str) -> List[Dict[str, str]]:
 def _get_pydantic_test_configs(
     dir_: str, *, python_version: str = "3.11"
 ) -> List[Dict[str, str]]:
-    with open("./libs/core/poetry.lock", "rb") as f:
-        core_poetry_lock_data = tomllib.load(f)
-    for package in core_poetry_lock_data["package"]:
+    with open("./libs/core/uv.lock", "rb") as f:
+        core_uv_lock_data = tomllib.load(f)
+    for package in core_uv_lock_data["package"]:
         if package["name"] == "pydantic":
             core_max_pydantic_minor = package["version"].split(".")[1]
             break
 
-    with open(f"./{dir_}/poetry.lock", "rb") as f:
-        dir_poetry_lock_data = tomllib.load(f)
+    with open(f"./{dir_}/uv.lock", "rb") as f:
+        dir_uv_lock_data = tomllib.load(f)
 
-    for package in dir_poetry_lock_data["package"]:
+    for package in dir_uv_lock_data["package"]:
         if package["name"] == "pydantic":
             dir_max_pydantic_minor = package["version"].split(".")[1]
             break
@@ -304,7 +309,7 @@ if __name__ == "__main__":
                 f"Unknown lib: {file}. check_diff.py likely needs "
                 "an update for this new library!"
             )
-        elif file.startswith("docs/") or file in ["pyproject.toml", "poetry.lock"]: # docs or root poetry files
+        elif file.startswith("docs/") or file in ["pyproject.toml", "uv.lock"]: # docs or root uv files
             docs_edited = True
             dirs_to_run["lint"].add(".")
 

.github/scripts/check_prerelease_dependencies.py

@@ -10,26 +10,25 @@ if __name__ == "__main__":
         toml_data = tomllib.load(file)
 
     # see if we're releasing an rc
-    version = toml_data["tool"]["poetry"]["version"]
+    version = toml_data["project"]["version"]
     releasing_rc = "rc" in version or "dev" in version
 
     # if not, iterate through dependencies and make sure none allow prereleases
     if not releasing_rc:
-        dependencies = toml_data["tool"]["poetry"]["dependencies"]
-        for lib in dependencies:
-            dep_version = dependencies[lib]
+        dependencies = toml_data["project"]["dependencies"]
+        for dep_version in dependencies:
             dep_version_string = (
                 dep_version["version"] if isinstance(dep_version, dict) else dep_version
             )
 
             if "rc" in dep_version_string:
                 raise ValueError(
-                    f"Dependency {lib} has a prerelease version. Please remove this."
+                    f"Dependency {dep_version} has a prerelease version. Please remove this."
                 )
 
             if isinstance(dep_version, dict) and dep_version.get(
                 "allow-prereleases", False
             ):
                 raise ValueError(
-                    f"Dependency {lib} has allow-prereleases set to true. Please remove this."
+                    f"Dependency {dep_version} has allow-prereleases set to true. Please remove this."
                 )

.github/scripts/get_min_versions.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 import sys
 from typing import Optional
 
@@ -7,6 +8,7 @@ else:
     # for python 3.10 and below, which doesnt have stdlib tomllib
     import tomli as tomllib
 
+from packaging.requirements import Requirement
 from packaging.specifiers import SpecifierSet
 from packaging.version import Version
 
@@ -94,6 +96,23 @@ def get_minimum_version(package_name: str, spec_string: str) -> Optional[str]:
     return str(min(valid_versions)) if valid_versions else None
 
 
+def _check_python_version_from_requirement(
+    requirement: Requirement, python_version: str
+) -> bool:
+    if not requirement.marker:
+        return True
+    else:
+        marker_str = str(requirement.marker)
+        if "python_version" or "python_full_version" in marker_str:
+            python_version_str = "".join(
+                char
+                for char in marker_str
+                if char.isdigit() or char in (".", "<", ">", "=", ",")
+            )
+            return check_python_version(python_version, python_version_str)
+        return True
+
+
 def get_min_version_from_toml(
     toml_path: str,
     versions_for: str,
@@ -105,8 +124,10 @@ def get_min_version_from_toml(
     with open(toml_path, "rb") as file:
         toml_data = tomllib.load(file)
 
-    # Get the dependencies from tool.poetry.dependencies
-    dependencies = toml_data["tool"]["poetry"]["dependencies"]
+    dependencies = defaultdict(list)
+    for dep in toml_data["project"]["dependencies"]:
+        requirement = Requirement(dep)
+        dependencies[requirement.name].append(requirement)
 
     # Initialize a dictionary to store the minimum versions
     min_versions = {}
@@ -121,17 +142,11 @@ def get_min_version_from_toml(
         if lib in dependencies:
             if include and lib not in include:
                 continue
-            # Get the version string
-            version_string = dependencies[lib]
-
-            if isinstance(version_string, dict):
-                version_string = version_string["version"]
-            if isinstance(version_string, list):
-                version_string = [
-                    vs
-                    for vs in version_string
-                    if check_python_version(python_version, vs["python"])
-                ][0]["version"]
+            requirements = dependencies[lib]
+            for requirement in requirements:
+                if _check_python_version_from_requirement(requirement, python_version):
+                    version_string = str(requirement.specifier)
+                    break
 
             # Use parse_version to get the minimum supported version from version_string
             min_version = get_minimum_version(lib, version_string)