Normalmente você usa:

* `POST`: para criar dados.
* `GET`: para ler dados.
* `PUT`: para atualizar dados.
* `DELETE`: para deletar dados.

Portanto, no OpenAPI, cada um dos métodos HTTP é chamado de "operação".

Vamos chamá-los de "**operações**" também.

#### Defina um *decorador de rota*

```Python hl_lines="6"

  EXPECT_EQ(22, product[3]);
  TF_DeleteStatus(status);
}
TEST(CAPI, Executor_MatMul_CPU) { Executor_MatMul_CPU(false); }
TEST(CAPI, Executor_MatMul_CPUAsync) { Executor_MatMul_CPU(true); }

void Deleter(void* data, size_t unused, void* tensor_handle) {
  TFE_DeleteTensorHandle(static_cast<TFE_TensorHandle*>(tensor_handle));
}

TEST(CAPI, TensorHandleOnDeviceMemory) {
  TF_Status* status = TF_NewStatus();

  ASSERT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);

  // Get attr
  AttrValue read_attr;
  GetAttr("test_attr_name", &read_attr);
  ASSERT_EQ(attr.DebugString(), read_attr.DebugString());

  // Retrieve the same attr after save/restore
  Reincarnate();
  AttrValue read_attr2;
  GetAttr("test_attr_name", &read_attr2);
  ASSERT_EQ(attr.DebugString(), read_attr2.DebugString());
}

        self, dependency: Optional[Callable[..., Any]] = None, *, use_cache: bool = True
    ):
        self.dependency = dependency
        self.use_cache = use_cache

    def __repr__(self) -> str:
        attr = getattr(self.dependency, "__name__", type(self.dependency).__name__)
        cache = "" if self.use_cache else ", use_cache=False"
        return f"{self.__class__.__name__}({attr}{cache})"


class Security(Depends):

    compresses messages of size 1 KiB and larger. (Inbound messages are compressed or not based on
    the web socket server's configuration.)
 *  New: Defer constructing `Inflater` and `Deflater` instances until they are needed. This saves
    memory if web socket compression is negotiated but not used.


## Version 4.5.0-RC1

_2020-03-17_

                "/"
            ), "A path prefix must not end with '/', as the routes will start with '/'"
        else:
            for r in router.routes:
                path = getattr(r, "path")  # noqa: B009
                name = getattr(r, "name", "unknown")
                if path is not None and not path:
                    raise FastAPIError(

// subject to change. Primarily intended for internal libraries
TF_CAPI_EXPORT extern void TF_ColocateWith(TF_OperationDescription* desc,
                                           TF_Operation* op);

// Call some TF_SetAttr*() function for every attr that is not
// inferred from an input and doesn't have a default value you wish to
// keep.

// `value` must point to a string of length `length` bytes.

                                                              TF_Status*);

// Creates a new TensorHandle from memory residing in the physical device
// device_name. Takes ownership of the memory, and will call deleter to release
// it after TF no longer needs it or in case of error.
//
// Custom devices must use TFE_NewCustomDeviceTensorHandle instead.
TF_CAPI_EXPORT extern TFE_TensorHandle* TFE_NewTensorHandleFromDeviceMemory(

pkg syscall (freebsd-arm64), const RTM_ADD ideal-int
pkg syscall (freebsd-arm64), const RTM_CHANGE = 3
pkg syscall (freebsd-arm64), const RTM_CHANGE ideal-int
pkg syscall (freebsd-arm64), const RTM_DELADDR = 13
pkg syscall (freebsd-arm64), const RTM_DELADDR ideal-int
pkg syscall (freebsd-arm64), const RTM_DELETE = 2
pkg syscall (freebsd-arm64), const RTM_DELETE ideal-int
pkg syscall (freebsd-arm64), const RTM_DELMADDR = 16

pkg syscall (freebsd-riscv64), const RTM_CHANGE = 3 #53466
pkg syscall (freebsd-riscv64), const RTM_CHANGE ideal-int #53466
pkg syscall (freebsd-riscv64), const RTM_DELADDR = 13 #53466
pkg syscall (freebsd-riscv64), const RTM_DELADDR ideal-int #53466
pkg syscall (freebsd-riscv64), const RTM_DELETE = 2 #53466
pkg syscall (freebsd-riscv64), const RTM_DELETE ideal-int #53466