# `Request` class

You can declare a parameter in a *path operation function* or dependency to be of type `Request` and then you can access the raw request object directly, without any validation, etc.

You can import it directly from `fastapi`:

```python
from fastapi import Request
```

!!! tip

{!../../../docs_src/custom_request_and_route/tutorial001.py!}
```

!!! note "📡 ℹ"
     `Request` ✔️ `request.scope` 🔢, 👈 🐍 `dict` ⚗ 🗃 🔗 📨.

     `Request` ✔️ `request.receive`, 👈 🔢 "📨" 💪 📨.

     `scope` `dict` & `receive` 🔢 👯‍♂️ 🍕 🔫 🔧.

     & 👈 2️⃣ 👜, `scope` & `receive`, ⚫️❔ 💪 ✍ 🆕 `Request` 👐.

Hasan Sezer Taşan <******@****.***> 1715195446 +0300

  CHECK(status.ok()) << "Failed to setup request context: " << status.message();

  auto req_ctx = std::move(builder).build();
  if (auto err = req_ctx.takeError())
    LOG(FATAL) << "Failed to build a request context";

  exec_ctx_ = std::make_unique<tfrt::ExecutionContext>(std::move(*req_ctx));
}

void RuntimeFallbackExecutor::Prepare(llvm::StringRef mlir_input) {

                InternalSession.from(nonNull(request, "request").getSession());
        DependencyResolverResult result;
        DependencyResolverResult collectorResult = collect(request);
        if (request.getRequestType() == DependencyResolverRequest.RequestType.COLLECT) {
            result = collectorResult;
        } else {
            List<Node> nodes = flatten(session, collectorResult.getRoot(), request.getPathScope());

# - Allow request principal ******@****.***/sub-1 to access path /token1
# - Allow request in group-2 to access path /token2
# - Allow request with any token to access path /tokenAny
# - Allow request with permission claim of "write" or "append" to access path /permission
# - Allow request with valid JWT token to access path /jwt1

		}
		reportValidationFailed(request, reasonInvalidConfig, isDryRun)
		return toAdmissionResponse(fmt.Errorf("configuration is invalid: %v", err))
	}

	if reason, err := checkFields(request.Object.Raw, request.Kind.Kind, request.Namespace, obj.Name); err != nil {
		reportValidationFailed(request, reason, isDryRun)
		return toAdmissionResponse(err)
	}

	reportValidationPass(request)

	return ""
}

func TestShouldRespond(t *testing.T) {
	tests := []struct {
		name     string
		proxy    *TestProxy
		request  *discovery.DiscoveryRequest
		response bool
	}{
		{
			name: "initial request",
			proxy: &TestProxy{
				WatchedResources: map[string]*WatchedResource{},
			},
			request: &discovery.DiscoveryRequest{
				TypeUrl: model.ClusterType,
			},
			response: true,
		},
		{
			name: "ack",

        result.beginControlFlow("if (invocation.getArgsCount() == $L)", argCount);
        CodeBlock argsCode = prepareInvocationArgs(request);
        emitInvocationCodeWithReturn(request, argsCode);
        result.endControlFlow();
    }

    private CodeBlock prepareInvocationArgs(CallInterceptionRequest request) {

import org.gradle.process.internal.worker.request.Receiver;
import org.gradle.process.internal.worker.request.Request;
import org.gradle.process.internal.worker.request.RequestArgumentSerializers;
import org.gradle.process.internal.worker.request.RequestProtocol;
import org.gradle.process.internal.worker.request.RequestSerializerRegistry;
import org.gradle.process.internal.worker.request.ResponseProtocol;