"cmd/go/internal/mvs"
	"cmd/go/internal/par"

	"golang.org/x/mod/module"
)

// A Requirements represents a logically-immutable set of root module requirements.
type Requirements struct {
	// pruning is the pruning at which the requirement graph is computed.
	//
	// If unpruned, the graph includes all transitive requirements regardless
	// of whether the requiring module supports pruning.
	//

```
.
├── Dockerfile
├── main.py
└── requirements.txt
```

Вам нужно изменить в `Dockerfile` соответствующие пути копирования файлов:

```{ .dockerfile .annotate hl_lines="10  13" }
FROM python:3.9

WORKDIR /code

COPY ./requirements.txt /code/requirements.txt

RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt

# (1)
COPY ./main.py /code/

# (2)

			Tags:                  tags,
			ResolveMissingImports: true,
			SilencePackageErrors:  true,
		},
		requirements: rs,
		listRoots: func(*Requirements) (roots []string) {
			roots = append(roots, imports...)
			roots = append(roots, testImports...)
			return roots
		},
	})
	requirements = loaded.requirements

	if !ExplicitWriteGoMod {
		if err := commitRequirements(ctx, WriteOpts{}); err != nil {

// use LoadModGraph instead.
func LoadModFile(ctx context.Context) *Requirements {
	rs, err := loadModFile(ctx, nil)
	if err != nil {
		base.Fatal(err)
	}
	return rs
}

func loadModFile(ctx context.Context, opts *PackageOpts) (*Requirements, error) {
	if requirements != nil {
		return requirements, nil
	}

	Init()
	var workFile *modfile.WorkFile
	if inWorkspaceMode() {

	// Ref: https://istio.io/latest/docs/ops/deployment/requirements/#pod-requirements
	if pod.Spec.SecurityContext != nil && pod.Spec.SecurityContext.RunAsUser != nil {
		if *pod.Spec.SecurityContext.RunAsUser == UserID {
			fmt.Fprintf(writer, "   WARNING: User ID (UID) 1337 is reserved for the sidecar proxy.\n")
		}
	}

	// https://istio.io/docs/setup/kubernetes/additional-setup/requirements/

				// selected version of curM, then we will fail in checkWildcardVersions.
				// (This could be an error, but it's too soon to tell.)
				//
				// However, even then the transitive requirements of some other query
				// may downgrade this module out of the build list entirely, in which
				// case the pattern will no longer include it and it won't be an error.
				//

		default:
			st.fail("unrecognized requirement code")
		}

		requirements = append(requirements, req)
	}

	if len(st.str) == 0 || st.str[0] != 'E' {
		st.fail("expected E after requirements")
	}
	st.advance(1)

	return &RequiresExpr{
		Params:       params,
		Requirements: requirements,
	}
}

// exprPrimary parses:
//

func validateCtx(ctx schedCtx, reqs event.SchedReqs) error {
	// Check thread requirements.
	if reqs.Thread == event.MustHave && ctx.M == NoThread {
		return fmt.Errorf("expected a thread but didn't have one")
	} else if reqs.Thread == event.MustNotHave && ctx.M != NoThread {
		return fmt.Errorf("expected no thread but had one")
	}

	// Check proc requirements.
	if reqs.Proc == event.MustHave && ctx.P == NoProc {

	CALL	runtime·libpreinit(SB)

	// Create a new thread to finish Go runtime initialization.
	MOVQ	_cgo_sys_thread_create(SB), AX
	TESTQ	AX, AX
	JZ	nocgo

	// We're calling back to C.
	// Align stack per ELF ABI requirements.
	MOVQ	SP, BX  // Callee-save in C ABI
	ANDQ	$~15, SP
	MOVQ	$_rt0_amd64_lib_go(SB), DI
	MOVQ	$0, SI
	CALL	AX
	MOVQ	BX, SP
	JMP	restore

nocgo:
	ADJSP	$16
	MOVQ	$0x800000, 0(SP)		// stacksize

These different <<sub:using_child_copy_specifications,levels of granularity>> in the copy specification allow you to handle most requirements that you will come across easily.

[[sec:copying_files]]
=== Understanding file copying

The basic process of copying files in Gradle is a simple one: