improve python version parsing to handle >=x,<y (#641)

* improve python version parsing to handle >=x,<y

* refactor setup.py handling as well

Author: davidzhao

pkg/agentfs/sdk_version_check.go

@@ -132,6 +132,57 @@ func checkPackageInFile(filePath string, projectType ProjectType, pythonMinVersi
 	return VersionCheckResult{Error: fmt.Errorf("unsupported file type: %s", fileName)}
 }
 
+// parsePythonPackageVersion parses a Python package line and extracts the version
+func parsePythonPackageVersion(line string) (string, bool) {
+	// match with optional extras and version specifiers
+	pattern := regexp.MustCompile(`(?i)^livekit-agents(?:\[[^\]]+\])?\s*([=~><!]+)?\s*([^#]+)?`)
+	matches := pattern.FindStringSubmatch(line)
+	if matches == nil {
+		return "", false
+	}
+
+	// get the operator (==, >=, etc.) and the version
+	operator := matches[1]
+	version := strings.TrimSpace(matches[2])
+
+	if version == "" {
+		// no version specified means latest
+		return "latest", true
+	}
+
+	// clean up the version string if it contains multiple constraints
+	// handle comma-separated version constraints like ">=1.2.5,<2"
+	if strings.Contains(version, ",") {
+		parts := strings.Split(version, ",")
+		for _, part := range parts {
+			trimmed := strings.TrimSpace(part)
+			if regexp.MustCompile(`\d`).MatchString(trimmed) {
+				if strings.ContainsAny(trimmed, "=~><") {
+					version = trimmed
+				} else if operator != "" {
+					version = operator + trimmed
+				} else {
+					version = trimmed
+				}
+				break
+			}
+		}
+	} else {
+		// handle space-separated constraints
+		firstPart := strings.Split(version, " ")[0]
+		// output expects operator, so we'll preserve or add it
+		if strings.ContainsAny(firstPart, "=~><") {
+			version = firstPart
+		} else if operator != "" {
+			version = operator + firstPart
+		} else {
+			version = firstPart
+		}
+	}
+
+	return version, true
+}
+
 // checkRequirementsFile checks for livekit-agents in requirements.txt
 func checkRequirementsFile(filePath, minVersion string) VersionCheckResult {
 	content, err := os.ReadFile(filePath)
@@ -146,15 +197,8 @@ func checkRequirementsFile(filePath, minVersion string) VersionCheckResult {
 			continue
 		}
 
-		// Match livekit-agents with optional extras and version specifiers
-		pattern := regexp.MustCompile(`(?i)^livekit-agents(?:\[[^\]]+\])?\s*([=~><!]+)?\s*([^#\s]+)?`)
-		matches := pattern.FindStringSubmatch(line)
-		if matches != nil {
-			version := strings.TrimSpace(matches[2])
-			if version == "" {
-				version = "latest" // No version specified means latest
-			}
-
+		version, found := parsePythonPackageVersion(line)
+		if found {
 			satisfied, err := isVersionSatisfied(version, minVersion)
 			return VersionCheckResult{
 				PackageInfo: PackageInfo{
@@ -191,14 +235,8 @@ func checkPyprojectToml(filePath, minVersion string) VersionCheckResult {
 		if deps, ok := project["dependencies"].([]any); ok {
 			for _, dep := range deps {
 				if line, ok := dep.(string); ok {
-					pattern := regexp.MustCompile(`(?i)^livekit-agents(?:\[[^\]]+\])?\s*([=~><!]+)?\s*([^#\s]+)?`)
-					matches := pattern.FindStringSubmatch(line)
-					if matches != nil {
-						version := strings.TrimSpace(matches[2])
-						if version == "" {
-							version = "latest"
-						}
-
+					version, found := parsePythonPackageVersion(line)
+					if found {
 						satisfied, err := isVersionSatisfied(version, minVersion)
 						return VersionCheckResult{
 							PackageInfo: PackageInfo{
@@ -264,35 +302,37 @@ func checkSetupPy(filePath, minVersion string) VersionCheckResult {
 
 	// Look for install_requires or dependencies
 	patterns := []*regexp.Regexp{
-		regexp.MustCompile(`(?i)install_requires\s*=\s*\[(.*?)\]`),
-		regexp.MustCompile(`(?i)dependencies\s*=\s*\[(.*?)\]`),
+		regexp.MustCompile(`(?i)install_requires\s*=\s*\[([\s\S]*?)\]`),
+		regexp.MustCompile(`(?i)dependencies\s*=\s*\[([\s\S]*?)\]`),
 	}
 
 	for _, pattern := range patterns {
 		matches := pattern.FindStringSubmatch(string(content))
 		if matches != nil {
 			depsSection := matches[1]
-			// Parse the dependencies section
-			depPattern := regexp.MustCompile(`(?i)["']livekit-agents(?:\[[^\]]+\])?\s*([=~><!]+)?\s*([^"'\s]+)?["']`)
+			// extract the livekit-agents dependency line
+			depPattern := regexp.MustCompile(`(?i)["']livekit-agents(?:\[[^\]]+\])?([^"']+)?["']`)
 			depMatches := depPattern.FindStringSubmatch(depsSection)
 			if depMatches != nil {
-				version := strings.TrimSpace(depMatches[2])
-				if version == "" {
-					version = "latest"
+				packageLine := "livekit-agents"
+				if depMatches[1] != "" {
+					packageLine += depMatches[1]
 				}
-
-				satisfied, err := isVersionSatisfied(version, minVersion)
-				return VersionCheckResult{
-					PackageInfo: PackageInfo{
-						Name:        "livekit-agents",
-						Version:     version,
-						FoundInFile: filePath,
-						ProjectType: ProjectTypePythonPip,
-						Ecosystem:   "pypi",
-					},
-					MinVersion: minVersion,
-					Satisfied:  satisfied,
-					Error:      err,
+				version, found := parsePythonPackageVersion(packageLine)
+				if found {
+					satisfied, err := isVersionSatisfied(version, minVersion)
+					return VersionCheckResult{
+						PackageInfo: PackageInfo{
+							Name:        "livekit-agents",
+							Version:     version,
+							FoundInFile: filePath,
+							ProjectType: ProjectTypePythonPip,
+							Ecosystem:   "pypi",
+						},
+						MinVersion: minVersion,
+						Satisfied:  satisfied,
+						Error:      err,
+					}
 				}
 			}
 		}

pkg/agentfs/sdk_version_check_test.go

@@ -26,6 +26,21 @@ func TestCheckSDKVersion(t *testing.T) {
 		expectError bool
 		errorMsg    string
 	}{
+		{
+			name:        "Python setup.py with valid version",
+			projectType: ProjectTypePythonPip,
+			setupFiles: map[string]string{
+				"setup.py": `setup(
+    name="my-project",
+    version="1.0.0",
+    install_requires=[
+        "livekit-agents>=1.5.0",
+        "requests==2.25.1",
+    ],
+)`,
+			},
+			expectError: false,
+		},
 		{
 			name:        "Python requirements.txt with valid version",
 			projectType: ProjectTypePythonPip,
@@ -52,6 +67,15 @@ dependencies = ["livekit-agents>=1.0.0"]`,
 			},
 			expectError: false,
 		},
+		{
+			name:        "Python pyproject.toml with comma-separated constraints",
+			projectType: ProjectTypePythonPip,
+			setupFiles: map[string]string{
+				"pyproject.toml": `[project]
+dependencies = ["livekit-agents>=1.2.5,<2"]`,
+			},
+			expectError: false,
+		},
 		{
 			name:        "Python Pipfile with valid version",
 			projectType: ProjectTypePythonPip,
@@ -351,3 +375,67 @@ func contains(s, substr string) bool {
 				return false
 			}())))
 }
+
+func TestParsePythonPackageVersion(t *testing.T) {
+	tests := []struct {
+		name           string
+		input          string
+		expectedOutput string
+		expectedFound  bool
+	}{
+		{
+			name:           "Simple version",
+			input:          "livekit-agents==1.5.0",
+			expectedOutput: "==1.5.0",
+			expectedFound:  true,
+		},
+		{
+			name:           "Version with extras",
+			input:          "livekit-agents[extra]==1.5.0",
+			expectedOutput: "==1.5.0",
+			expectedFound:  true,
+		},
+		{
+			name:           "Version with no specifier",
+			input:          "livekit-agents",
+			expectedOutput: "latest",
+			expectedFound:  true,
+		},
+		{
+			name:           "Version with greater than",
+			input:          "livekit-agents>=1.5.0",
+			expectedOutput: ">=1.5.0",
+			expectedFound:  true,
+		},
+		{
+			name:           "Comma-separated constraints",
+			input:          "livekit-agents>=1.2.5,<2",
+			expectedOutput: ">=1.2.5",
+			expectedFound:  true,
+		},
+		{
+			name:           "Space-separated constraints",
+			input:          "livekit-agents>=1.2.5 <2",
+			expectedOutput: ">=1.2.5",
+			expectedFound:  true,
+		},
+		{
+			name:           "Not livekit-agents",
+			input:          "some-other-package==1.0.0",
+			expectedOutput: "",
+			expectedFound:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			output, found := parsePythonPackageVersion(tt.input)
+			if found != tt.expectedFound {
+				t.Errorf("Expected found=%v, got %v", tt.expectedFound, found)
+			}
+			if output != tt.expectedOutput {
+				t.Errorf("Expected output=%q, got %q", tt.expectedOutput, output)
+			}
+		})
+	}
+}