feat: Add the main file for determine package reachability level of Python project by p1gc0rn · Pull Request #2131 · google/osv-scanner

p1gc0rn · 2025-08-01T01:18:35Z

The new feature helps determine the reachability of imported Python libraries in a Python project. This is part of the under developing project for imported Python libraries' reachability.

This PR includes the support for imported Python libraries defined in poetry.lock file.

experimental/main.go

experimental/main_test.go

experimental/main.go

cuixq · 2025-08-01T07:07:55Z

can you add some description for this PR?

cuixq

also let's move this to experimental/pythonreach folder and add a README file.

cuixq · 2025-09-24T04:54:00Z

experimental/pythonreach/example/poetry.lock

@@ -0,0 +1,415 @@
+# This file is automatically @generated by Poetry 2.1.3 and should not be changed by hand.


I don't see this example project is being referenced anywhere in test?

this is for running with the main.go in CLI. go run main.go --directory=example

experimental/pythonreach/main.go

cuixq · 2025-09-24T05:21:21Z

experimental/pythonreach/main.go

+
+		// 6. Comparison between the collected imported libraries and the PYPI dependencies of the libraries
+		// to find the reachability of the PYPI dependencies.
+		for _, library := range importedLibraries {


let's make a struct for the output so that we can test the reachability result properly as well.

https://github.com/google/osv-scalibr/blob/main/enricher/reachability/java/java.go can be a reference about what the results should look like.

cuixq · 2025-09-24T06:24:45Z

experimental/pythonreach/main_test.go

+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := context.Background()


you may use t.Context() for context in testing

experimental/pythonreach/main_test.go

experimental/pythonreach/main.go

cuixq · 2025-09-24T06:54:04Z

experimental/pythonreach/main.go

+		}
+	}
+
+	downloadFileSource, err := downloadPackageSource(downloadURL)


you may find https://github.com/google/osv-scalibr/blob/629500d6fb6a1392afe40e0c9327c48a787358d8/clients/datasource/pypi_registry.go#L91 useful

thank you for the link!

experimental/pythonreach/testdata/multifileswithentrypoint/script.sh

experimental/pythonreach/testdata/multifileswithentrypoint/main.py

cuixq · 2025-09-24T06:58:56Z

we probably need go.mod as well

github-actions · 2025-12-13T02:29:29Z

This pull request has not had any activity for 60 days and will be automatically closed in two weeks

github-actions · 2025-12-27T02:30:31Z

Automatically closing stale pull request

cuixq · 2026-01-19T04:17:23Z

/gemini review

gemini-code-assist

Code Review

This PR introduces a new tool for analyzing Python dependency reachability, which is a great feature. The implementation follows a logical flow: finding entry points, parsing manifests, analyzing imports, and then diving into library source code. However, the current implementation has several critical and high-severity issues that need to be addressed. The tool downloads and extracts package source code into the current working directory, which is unsafe. There are cases where errors are ignored, which can lead to panics. The logic for identifying manifest files and parsing Python code has some flaws that will cause the tool to fail on valid projects or produce incorrect results. I've left specific comments on these points. Addressing these issues will significantly improve the tool's reliability and usability.

experimental/pythonreach/main.go

gemini-code-assist · 2026-01-19T04:19:42Z

experimental/pythonreach/main.go

+	// TODO: Find alternative ways for these regexes.
+	mainEntryRegex    = regexp.MustCompile(`^\s*if\s+__name__\s*==\s*['"]__main__['"]\s*:`)
+	importRegex       = regexp.MustCompile(`^\s*import\s+([a-zA-Z0-9_.]+)(?:\s+as\s+([a-zA-Z0-9_]+))?`)
+	fromImportRegex   = regexp.MustCompile(`^\s*from\s+([a-zA-Z0-9_.]+)\s+import\s+(.+)`)


The regular expression for from ... import ... statements does not handle multi-line imports that use parentheses, such as:

from my_library import ( module1, module2, )

The current regex ^\s*from\s+([a-zA-Z0-9_.]+)\s+import\s+(.+) will only capture the first line. To handle this, you would need a more complex parsing logic that can read across multiple lines when an opening parenthesis is detected.

experimental/pythonreach/main.go

gemini-code-assist · 2026-01-19T04:19:42Z

experimental/pythonreach/main.go

+
+		return scanFile(file, func(line string) error {
+			for _, module := range libraryInfo.Modules {
+				searchTerm := fmt.Sprintf("def %s(", module.Name)


The method for finding where an imported item is defined is based on a simple string search: searchTerm := fmt.Sprintf("def %s(", module.Name). This is not very robust and can lead to both false positives and false negatives.

False positives: It can match function names in comments or strings.

False negatives: It won't match functions with different spacing (e.g., def my_func(...)), functions defined in classes (methods), or other imported symbols like classes or variables.
Consider using regular expressions or, for a more robust solution, a Python AST parser to accurately locate definitions.

gemini-code-assist · 2026-01-19T04:19:42Z

experimental/pythonreach/main.go

+			}
+
+			for _, module := range library.Modules {
+				if module.SourceDefinedPaths == nil {


The logic here assumes that if the source definition path for a module is not found (module.SourceDefinedPaths == nil), all of the library's dependencies are reachable. This is a risky assumption and can lead to incorrect reachability analysis. It would be better to report the reachability as "unknown" or "undetermined" in this case, rather than defaulting to "reachable". This makes the tool's output more accurate about its limitations.

experimental/pythonreach/main_test.go

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

p1gc0rn · 2026-02-10T04:14:30Z

/gemini review

gemini-code-assist

Code Review

This pull request introduces a new tool to determine the reachability of dependencies in a Python project, starting with support for poetry.lock. The implementation is a great start and covers the end-to-end flow from parsing manifests to analyzing library source code.

My review focuses on improving the robustness and correctness of the implementation. The main points of feedback are:

Replacing fragile regex-based Python code parsing with a more reliable AST-based approach to handle various import syntaxes correctly.
Improving error handling and resource management to make the tool more resilient.
Increasing test coverage for the core analysis logic to ensure correctness and prevent future regressions.

I've provided specific suggestions for each of these points in the comments.

gemini-code-assist · 2026-02-10T04:16:55Z

experimental/pythonreach/main.go

+	// TODO: Find alternative ways for these regexes.
+	mainEntryRegex    = regexp.MustCompile(`^\s*if\s+__name__\s*==\s*['"]__main__['"]\s*:`)
+	importRegex       = regexp.MustCompile(`^\s*import\s+([a-zA-Z0-9_.]+)(?:\s+as\s+([a-zA-Z0-9_]+))?`)
+	fromImportRegex   = regexp.MustCompile(`^\s*from\s+([a-zA-Z0-9_.]+)\s+import\s+(.+)`)
+	importItemRegex   = regexp.MustCompile(`([a-zA-Z0-9_.*]+)(?:\s+as\s+([a-zA-Z0-9_]+))?`)
+	memberImportRegex = regexp.MustCompile(`^\s*import (\w+)\.(\w+)`)


The current implementation uses regular expressions to parse Python import statements and search for function definitions (e.g., in getImportedItemsFilePaths). This approach is brittle and can easily fail with different code formatting, or for constructs other than simple function imports (like classes or variables). The TODO comment acknowledges this.

To make the analysis robust and accurate, I strongly recommend using a Go library that can parse Python code into an Abstract Syntax Tree (AST). Libraries like github.com/go-python/gpython/parser would allow you to reliably identify all imported symbols and their definitions. This is crucial for the correctness of the reachability analysis.

experimental/pythonreach/main_test.go

experimental/pythonreach/main.go

gemini-code-assist · 2026-02-10T04:16:55Z

experimental/pythonreach/main.go

+	if err != nil {
+		log.Printf("failed to parse metadata from %s: %v", fileName, err)
+	}


When pypi.SdistMetadata fails, the error is logged, but the program continues. This means libraryInfo.Dependencies will be empty, leading to incorrect and misleading reachability results (it will report all dependencies as unreachable). This should be treated as a more significant error. I suggest either terminating the analysis for this library and reporting it as failed, or exiting the program entirely, to avoid producing incorrect output.

gemini-code-assist · 2026-02-10T04:16:55Z

experimental/pythonreach/main.go

+	tmpDir, err := os.MkdirTemp("", "pythonreach-src-")
+	if err != nil {
+		return fmt.Errorf("failed to create temp dir: %w", err)
+	}
+
+	tmpFile, err := os.CreateTemp(tmpDir, fileName)
+	if err != nil {
+		_ = os.RemoveAll(tmpDir)
+		return fmt.Errorf("failed to create temp file: %w", err)
+	}
+
+	if _, err := io.Copy(tmpFile, bytes.NewReader(sourceFile)); err != nil {
+		tmpFile.Close()
+		_ = os.RemoveAll(tmpDir)
+		return fmt.Errorf("failed to write to temp file: %w", err)
+	}
+	if err := tmpFile.Close(); err != nil {
+		_ = os.RemoveAll(tmpDir)
+		return fmt.Errorf("failed to close temp file: %w", err)
+	}
+
+	// Re-open the temp file for extraction.
+	f, err := os.Open(tmpFile.Name())
+	if err != nil {
+		_ = os.RemoveAll(tmpDir)
+		return fmt.Errorf("failed to open temp file for extraction: %w", err)
+	}
+	defer f.Close()
+
+	if err := extractCompressedPackageSource(f, tmpDir); err != nil {
+		_ = os.RemoveAll(tmpDir)
+		return err
+	}
+
+	// Record the extracted source dir on the library info for later processing.
+	libraryInfo.SourceDir = tmpDir


The retrieveSourceAndCollectDependencies function downloads the entire package source into a memory buffer (sourceFile), then writes it to a temporary file, and then re-opens it for extraction. For large packages, this can be memory-intensive, and the intermediate disk I/O is unnecessary.

You can simplify this by modifying extractCompressedPackageSource to accept an io.Reader instead of an *os.File. Then, you can pass a bytes.NewReader(sourceFile) directly to it, avoiding the need to create, write, and re-open the temporary file for extraction. This will make the code simpler and more efficient.

experimental/pythonreach/main.go

p1gc0rn · 2026-02-10T05:04:53Z

/gemini review

gemini-code-assist

Code Review

This pull request introduces a new experimental tool for determining the reachability of Python package dependencies. The core logic is implemented in Go and currently supports projects using poetry.lock. While the overall goal is valuable, the current implementation has several significant issues related to correctness and robustness. The most critical problem is the reliance on regular expressions for parsing Python code, which is highly unreliable. Other major concerns include fragile logic for locating source files and symbol definitions, and bugs in file path handling. I've provided several high-severity comments and suggestions to address these fundamental issues. Addressing these points will be crucial for making the tool reliable.

experimental/pythonreach/main.go

gemini-code-assist · 2026-02-10T05:08:17Z

experimental/pythonreach/main.go

+func parsePoetryLock(ctx context.Context, fpath string) ([]*LibraryInfo, error) {
+	dir := filepath.Dir(fpath)
+	fsys := scalibrfs.DirFS(dir)
+	r, err := fsys.Open("poetry.lock")
+	if err != nil {
+		return nil, fmt.Errorf("failed to open %s: %w", fpath, err)
+	}
+	defer r.Close()
+
+	input := &filesystem.ScanInput{
+		FS:     fsys,
+		Path:   fpath,
+		Reader: r,
+	}
+	extractor := poetrylock.New()
+	inventory, err := extractor.Extract(ctx, input)
+	if err != nil {
+		return nil, fmt.Errorf("failed to extract from %s: %w", fpath, err)
+	}
+
+	libraryInfos := []*LibraryInfo{}
+	for _, i := range inventory.Packages {
+		libraryInfos = append(libraryInfos, &LibraryInfo{Name: i.Name, Version: i.Version})
+	}
+
+	return libraryInfos, nil
+}


The path handling in this function is incorrect. It receives a path fpath, but then it gets the parent directory (filepath.Dir) and tries to open a hardcoded "poetry.lock" file from there. This logic is fragile and will likely fail. The function should be self-contained and parse the file specified by fpath. This also requires a change at the call site in main().

func parsePoetryLock(ctx context.Context, fpath string) ([]*LibraryInfo, error) { dir := filepath.Dir(fpath) fname := filepath.Base(fpath) fsys := scalibrfs.DirFS(dir) r, err := fsys.Open(fname) if err != nil { return nil, fmt.Errorf("failed to open %s: %w", fpath, err) } defer r.Close() input := &filesystem.ScanInput{ FS: fsys, Path: fname, Reader: r, } extractor := poetrylock.New() inventory, err := extractor.Extract(ctx, input) if err != nil { return nil, fmt.Errorf("failed to extract from %s: %w", fpath, err) } libraryInfos := []*LibraryInfo{} for _, i := range inventory.Packages { libraryInfos = append(libraryInfos, &LibraryInfo{Name: i.Name, Version: i.Version}) } return libraryInfos, nil }

experimental/pythonreach/main.go

gemini-code-assist · 2026-02-10T05:08:17Z

experimental/pythonreach/main.go

+				searchTerm := fmt.Sprintf("def %s(", module.Name)
+				if strings.Contains(line, searchTerm) {


Using a simple string search for "def %s(" to find where an item is defined is highly unreliable. This approach will only find function definitions and will miss classes, variables, or entire submodules that are imported. It's also prone to false positives if the search term appears in comments or strings.

To accurately locate definitions, you should use an AST parser to identify function definitions, class definitions, and variable assignments at the top level of modules.

gemini-code-assist · 2026-02-10T05:08:17Z

experimental/pythonreach/main.go

+	poetryLibraryInfos := []*LibraryInfo{}
+	for _, manifestFile := range manifestFiles {
+		switch manifestFile {
+		case "poetry.lock":
+			// Parse the poetry.lock file to get library information.
+			poetryLibraryInfos, err = parsePoetryLock(ctx, filepath.Join(*directory))
+			if err != nil {
+				log.Printf("Error collecting libraries in poetry.lock: %v\n", err)
+			}
+		}
+	}


The logic for finding and parsing manifest files is flawed. The code identifies manifest files but then doesn't use the results. Instead, it makes a single, hardcoded call to parsePoetryLock with just the directory path, which is incorrect and will fail with the recommended fix in parsePoetryLock.

poetryLibraryInfos := []*LibraryInfo{} for _, manifestFile := range manifestFiles { switch manifestFile { case "poetry.lock": // Parse the poetry.lock file to get library information. fullPath := filepath.Join(*directory, manifestFile) libs, err := parsePoetryLock(ctx, fullPath) if err != nil { log.Printf("Error collecting libraries in poetry.lock: %v\n", err) continue } poetryLibraryInfos = append(poetryLibraryInfos, libs...) } }

gemini-code-assist · 2026-02-10T05:08:17Z

experimental/pythonreach/main.go

+					slices.Sort(module.ImportedLibraryNames)
+					importedLibs := slices.Compact(module.ImportedLibraryNames)
+					for _, importedLib := range importedLibs {
+						if strings.Contains(importedLib, dep) {


Using strings.Contains for checking if a dependency is used can lead to false positives. For example, a dependency named dep would incorrectly match an import of a library named dep-plus. This check should be more precise.

if strings.Split(importedLib, ".")[0] == dep {

experimental/pythonreach/main.go

gemini-code-assist · 2026-02-10T05:08:17Z

experimental/pythonreach/main.go

+		_ = os.RemoveAll(tmpDir)
+		return fmt.Errorf("failed to create temp file: %w", err)
+	}


Errors from os.RemoveAll are being ignored. While this is part of an error handling path for cleanup, failing to remove temporary directories can lead to disk space leaks over time. It's better practice to at least log these failures.

if err := os.RemoveAll(tmpDir); err != nil { log.Printf("failed to remove temp dir %s: %v", tmpDir, err) } return fmt.Errorf("failed to create temp file: %w", err)

gemini-code-assist · 2026-02-10T05:08:17Z

experimental/pythonreach/main.go

+}
+
+// findImportedItemPaths finds libraries in import statements in the files.
+func findImportedLibrary(libraryInfo *LibraryInfo) error {


The function name findImportedLibrary is ambiguous. Based on its implementation, it finds libraries that are imported within the source files of a given library's modules. A more descriptive name would improve code clarity.

func findImportsInModuleSourceFiles(libraryInfo *LibraryInfo) error {

experimental/pythonreach/main_test.go

p1gc0rn · 2026-02-18T23:05:19Z

/gemini review

gemini-code-assist

Code Review

This pull request introduces a new experimental tool to determine the reachability of dependencies in a Python project by analyzing import statements. The core logic is implemented in Go and supports poetry.lock files. While the overall structure and approach are sound, there are several critical correctness issues in the implementation. The use of regular expressions to parse Python import statements and find symbol definitions is brittle and incorrect in several key ways, which will lead to inaccurate results. I've provided specific feedback and suggestions to address these issues by improving the parsing logic. There are also opportunities to improve efficiency in file handling.

gemini-code-assist · 2026-02-18T23:06:59Z

experimental/pythonreach/main.go

+		if match := importRegex.FindStringSubmatch(line); match != nil {
+			libraryName := match[1]
+			alias := match[2]
+			lib := getOrCreateLibraryInfo(importedLibraries, libraryName)
+			lib.Alias = alias
+


The regular expression for import statements can incorrectly identify the library name for sub-module imports. For example, for import a.b.c, the library is a, but the regex captures a.b.c. This will cause failures when matching against dependencies. The top-level package should be extracted.

Suggested change

if match := importRegex.FindStringSubmatch(line); match != nil {

libraryName := match[1]

alias := match[2]

lib := getOrCreateLibraryInfo(importedLibraries, libraryName)

lib.Alias = alias

if match := importRegex.FindStringSubmatch(line); match != nil {

libraryName := strings.Split(match[1], ".")[0]

alias := match[2]

lib := getOrCreateLibraryInfo(importedLibraries, libraryName)

lib.Alias = alias

gemini-code-assist · 2026-02-18T23:06:59Z

experimental/pythonreach/main.go

+			libraryName := match[1]
+			items := match[2]
+
+			lib := getOrCreateLibraryInfo(importedLibraries, libraryName)


The regular expression for from ... import ... statements can incorrectly identify the library name for sub-module imports. For example, for from a.b import c, the library is a, but the regex captures a.b. This will cause failures when matching against dependencies. The top-level package should be extracted.

Suggested change

libraryName := match[1]

items := match[2]

lib := getOrCreateLibraryInfo(importedLibraries, libraryName)

libraryName := strings.Split(match[1], ".")[0]

items := match[2]

lib := getOrCreateLibraryInfo(importedLibraries, libraryName)

gemini-code-assist · 2026-02-18T23:06:59Z

experimental/pythonreach/main.go

+		} else if match := memberImportRegex.FindStringSubmatch(line); match != nil {
+			libraryName := match[1]
+			moduleName := match[2]
+
+			lib := getOrCreateLibraryInfo(importedLibraries, libraryName)
+			lib.Modules = append(lib.Modules, &ModuleInfo{Name: moduleName})
+		}


This regex ^\s*import (\w+)\.(\w+) seems to be intended to handle member imports, but it's redundant with the main importRegex and also incorrectly parses the library. The importRegex already handles import a.b, and as noted in another comment, it should be modified to extract the top-level package a. This block of code is likely unnecessary and contributes to incorrect parsing. This else if block can probably be removed entirely if the main importRegex logic is corrected to handle top-level package extraction.

gemini-code-assist · 2026-02-18T23:06:59Z

experimental/pythonreach/main.go

+
+		return scanFile(file, func(line string) error {
+			for _, module := range libraryInfo.Modules {
+				searchTerm := fmt.Sprintf("def %s(", module.Name)


Using a simple string search with fmt.Sprintf("def %s(", module.Name) to find function definitions is very brittle and will miss many cases. For example, it won't find:

Functions with different spacing or no arguments (def my_func() :).

async functions.

Class definitions (class MyClass:).

Imported variables.

This will lead to many imported symbols not being found in the source code, making the reachability analysis incomplete. To reliably locate definitions, you should use a Python Abstract Syntax Tree (AST) parser. There are Go libraries available for parsing Python code which would make this much more robust.

gemini-code-assist · 2026-02-18T23:06:59Z

experimental/pythonreach/main.go

+		for _, dep := range library.Dependencies {
+			reachable := false
+			for _, importedLib := range importedLibs {
+				if strings.Contains(importedLib, dep) {


The reachability check strings.Contains(importedLib, dep) is not safe and can produce false positives. For example, if a module imports a library named foobar and there is a dependency named foo, this check will incorrectly mark foo as reachable. The check should be for an exact match.

Suggested change

if strings.Contains(importedLib, dep) {

if importedLib == dep {

gemini-code-assist · 2026-02-18T23:06:59Z

experimental/pythonreach/main.go

+	tmpFile, err := os.CreateTemp(tmpDir, fileName)
+	if err != nil {
+		if err := os.RemoveAll(tmpDir); err != nil {
+			log.Printf("failed to remove temp dir %s: %v", tmpDir, err)
+		}
+		return fmt.Errorf("failed to create temp file: %w", err)
+	}
+
+	if _, err := io.Copy(tmpFile, bytes.NewReader(sourceFile)); err != nil {
+		tmpFile.Close()
+		if err := os.RemoveAll(tmpDir); err != nil {
+			log.Printf("failed to remove temp dir %s: %v", tmpDir, err)
+		}
+		return fmt.Errorf("failed to write to temp file: %w", err)
+	}
+	if err := tmpFile.Close(); err != nil {
+		if err := os.RemoveAll(tmpDir); err != nil {
+			log.Printf("failed to remove temp dir %s: %v", tmpDir, err)
+		}
+		return fmt.Errorf("failed to close temp file: %w", err)
+	}
+
+	// Re-open the temp file for extraction.
+	f, err := os.Open(tmpFile.Name())
+	if err != nil {
+		if err := os.RemoveAll(tmpDir); err != nil {
+			log.Printf("failed to remove temp dir %s: %v", tmpDir, err)
+		}
+		return fmt.Errorf("failed to open temp file for extraction: %w", err)
+	}
+	defer f.Close()
+
+	if err := extractCompressedPackageSource(f, tmpDir); err != nil {
+		if err := os.RemoveAll(tmpDir); err != nil {
+			log.Printf("failed to remove temp dir %s: %v", tmpDir, err)
+		}
+		return err
+	}


The function downloads the package source into an in-memory byte slice, writes it to a temporary file on disk, and then re-opens and reads that file to perform the extraction. This round-trip to disk is unnecessary and can be avoided.

p1gc0rn · 2026-02-18T23:20:41Z

/gemini review

gemini-code-assist · 2026-02-18T23:20:45Z

Warning

You have reached your daily quota limit. Please wait up to 24 hours and I will start processing your requests again!

Add the main file

9feba41

p1gc0rn requested a review from cuixq August 1, 2025 01:18

p1gc0rn changed the title ~~Add the main file for package reachability level~~ #feat Add the main file for package reachability level Aug 1, 2025

p1gc0rn changed the title ~~#feat Add the main file for package reachability level~~ feat: Add the main file for package reachability level Aug 1, 2025

Add a comment

388c206

cuixq reviewed Aug 1, 2025

View reviewed changes

p1gc0rn changed the title ~~feat: Add the main file for package reachability level~~ feat: Add the main file for determine package reachability level of Python project Aug 17, 2025

p1gc0rn added 5 commits August 17, 2025 21:35

Update main.go with suggestion changes

c26429c

Resolved comments

413dab2

Add helper function

fddeaf7

Add testdata

c5f2001

Clean up and add example of reachable library

a652588

cuixq reviewed Sep 24, 2025

View reviewed changes

github-actions bot added the stale The issue or PR is stale and pending automated closure label Dec 13, 2025

github-actions bot added the autoclosed Closed by automation label Dec 27, 2025

github-actions bot closed this Dec 27, 2025

cuixq removed autoclosed Closed by automation stale The issue or PR is stale and pending automated closure labels Dec 31, 2025

cuixq reopened this Dec 31, 2025

gemini-code-assist bot reviewed Jan 19, 2026

View reviewed changes

p1gc0rn and others added 4 commits February 9, 2026 10:31

Update experimental/pythonreach/main.go

a4fa0b3

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

Update main.go based on Gemini suggestion

8e9cfe2

Update main.go based on Gemini suggestion

365d9ea

Update main.go based on Gemini suggestions

1a361f0

Remove library files

1099f4e

gemini-code-assist bot reviewed Feb 10, 2026

View reviewed changes

Update main.go and main_test.gobased on Gemini suggestions

3afcc0a

gemini-code-assist bot reviewed Feb 10, 2026

View reviewed changes

p1gc0rn added 5 commits February 10, 2026 06:13

Update main.go based on Gemini suggestions

7fe1b96

Update main.go based on Gemini suggestions

eae2296

Resolve comments

6f7e9d2

Resolve comments

5aa1296

Resolve comments

a392668

gemini-code-assist bot reviewed Feb 18, 2026

View reviewed changes

Resolve comments

18b8a66

cuixq approved these changes Feb 20, 2026

View reviewed changes

cuixq merged commit 54f49bf into google:python-reach Feb 20, 2026
1 check passed

		@@ -0,0 +1,415 @@
		# This file is automatically @generated by Poetry 2.1.3 and should not be changed by hand.

		searchTerm := fmt.Sprintf("def %s(", module.Name)
		if strings.Contains(line, searchTerm) {

	if strings.Contains(importedLib, dep) {
	if importedLib == dep {

Comments

Conversation

p1gc0rn commented Aug 1, 2025 • edited by cuixq Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

cuixq commented Aug 1, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

cuixq left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

cuixq commented Sep 24, 2025

Uh oh!

github-actions bot commented Dec 13, 2025

Uh oh!

github-actions bot commented Dec 27, 2025

Uh oh!

cuixq commented Jan 19, 2026

Uh oh!

gemini-code-assist bot left a comment

Choose a reason for hiding this comment

Code Review

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

gemini-code-assist bot Jan 19, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

gemini-code-assist bot Jan 19, 2026

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Jan 19, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

p1gc0rn commented Feb 10, 2026

Uh oh!

gemini-code-assist bot left a comment

Choose a reason for hiding this comment

Code Review

Uh oh!

gemini-code-assist bot Feb 10, 2026

Choose a reason for hiding this comment

Uh oh!

p1gc0rn commented Aug 1, 2025 •

edited by cuixq

Loading

cuixq commented Aug 1, 2025 •

edited

Loading