### Generator Framework

The generator framework is a loose Model/View/Controller arrangement:

The *Model* classes live in the ***model/*** directory. They are representations
of the `OpDef` and `ApiDef` protos, normalized and resolved.

> _For example, an `OpDef` proto's `ArgDef` members contain a type string, which
> must be dereferenced to an `AttrDef` by name to determine its type. This

!!! tip "Dica"
    As próximas seções **não são necessáriamente "avançadas"**

    E é possível que para seu caso de uso, a solução esteja em uma delas.

## Leia o Tutorial primeiro

Você ainda pode usar a maior parte dos recursos no **FastAPI** com o conhecimento do [Tutorial - Guia de Usuário](../tutorial/index.md){.internal-link target=_blank}.

  // Test we can retrieve function OpDef from graph
  TF_Buffer* buffer = TF_NewBuffer();
  TF_GraphGetOpDef(host_graph_, func_name_, buffer, s_);
  ASSERT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);

  // Sanity check returned OpDef
  string data(static_cast<const char*>(buffer->data), buffer->length);
  OpDef op_def;
  op_def.ParseFromString(data);

OpenAPI tem uma forma para definir múltiplos “esquemas” de segurança.

Por usá-los, você pode ter vantagens de todas essas ferramentas baseadas nos padrões, incluindo os sistemas de documentação interativa.

OpenAPI define os seguintes esquemas de segurança:

* `apiKey`: uma chave específica de aplicação que pode vir de:
    * Um parâmetro query.
    * Um header.
    * Um cookie.

					// Decrement the expected number of deletes because the informer won't observe this deletion
					podKey := controller.PodKey(targetPod)
					rsc.expectations.DeletionObserved(logger, rsKey, podKey)
					if !apierrors.IsNotFound(err) {
						logger.V(2).Info("Failed to delete pod, decremented expectations", "pod", podKey, "kind", rsc.Kind, "replicaSet", klog.KObj(rs))
						errCh <- err
					}
				}
			}(pod)
		}

	podName := util.GetUniquePodName(pod)

	//let the pod be terminated
	podGet, exist := dswp.podManager.(mutablePodManager).GetPodByName(pod.Namespace, pod.Name)
	if !exist {
		t.Fatalf("Failed to get pod by pod name: %s and namespace: %s", pod.Name, pod.Namespace)
	}
	podGet.Status.Phase = v1.PodFailed
	dswp.podManager.(mutablePodManager).RemovePod(pod)

	dswp.findAndRemoveDeletedPods()

def tf_gen_op_wrappers_fuzz(
        name,
        op_def_src,
        api_def_srcs = [],
        kernel_deps = []):
    """
    Generates fuzzers for several groups of ops.

    For each one we need the corresponding OpDef, ApiDef and KernelDef,
    since they all can contain constraints for the inputs.

    Args:
        name: the name of the fuzz artifact
        op_def_src: op definitions
        api_def_srcs: api definitions

## Casos de uso

Por ejemplo, imagina que quieres retornar un HTTP status code de "OK" `200` por defecto.

Pero si los datos no existen, quieres crearlos y retornar un HTTP status code de "CREATED" `201`.

Pero aún quieres poder filtrar y convertir los datos que retornas con un `response_model`.

Para esos casos, puedes usar un parámetro `Response`.

## Usar un parámetro `Response`

		return false
	}

	if !match.MatchesGlobs(container, sp.Containers) {
		return false
	}

	if !match.MatchesGlobs(container, sp.Containers) {
		return false
	}

	key := cluster2.PodKey(namespace, pod)
	if !match.MatchesMap(sp.Labels, cluster.Labels[key]) {
		return false
	}
	if !match.MatchesMap(sp.Annotations, cluster.Annotations[key]) {
		return false
	}
	return true
}

// Delete NewFunctionLibraryDefinition.
TF_CAPI_EXPORT extern void TF_DeleteFunctionLibraryDefinition(
    TF_FunctionLibraryDefinition* fn_lib);

// Shorthand for calling LookUp to get the OpDef from FunctionLibraryDefinition
// given op name. The returned OpDef is represented by TF_Buffer.
TF_CAPI_EXPORT extern void TF_LookUpOpDef(TF_FunctionLibraryDefinition* fn_lib,
                                          const char* name, TF_Buffer* buf,