To add it to your *path operation*, declare it the same way you declared path and query parameters:

{* ../../docs_src/body/tutorial001_py310.py hl[16] *}

...and declare its type as the model you created, `Item`.

## Results

With just that Python type declaration, **FastAPI** will:

* Read the body of the request as JSON.
* Convert the corresponding types (if needed).
* Validate the data.

		}

		for p := range latestMeta.Parts {
			if verifyErr != nil {
				dataErrsByPart[p][i] = convPartErrToInt(verifyErr)
			} else {
				dataErrsByPart[p][i] = verifyResp.Results[p]
			}
		}
	}

	// Build dataErrs by disk from dataErrs by part
	for part, disks := range dataErrsByPart {
		for disk := range disks {
			dataErrsByDisk[disk][part] = dataErrsByPart[part][disk]
		}

				done = true
			}
		case <-ctx.Done():
			// Refreshing is canceled
			return false, ctx.Err()
		}
		if done {
			break
		}
	}

	// We may have some unused results in ch, release them async.
	go func() {
		wg.Wait()
		xioutil.SafeClose(ch)
		for range ch {
		}
	}()

	noQuorum := lockNotFound > len(restClnts)-quorum
	return noQuorum, nil
}

//     op for shape inference.
//   - The types need not be set in `input_shapes` as it is not used.
//   - The number of `input_tensors` should be the same as the number of items
//     in `input_shapes`.
//
// The results are returned in `output_shapes` and
// `output_resource_shapes_and_types`. The caller is responsible for freeing the
// memory in these buffers by calling `TF_DeleteShapeAndTypeList`.
TF_CAPI_EXPORT extern void TFE_InferShapes(

Vous écrivez le premier paramètre, `first_name`, puis un point (`.`) et appuyez sur `Ctrl+Espace` pour déclencher l'auto-complétion.

Mais malheureusement, rien d'utile n'en résulte :

<img src="/img/python-types/image01.png">

### Ajouter des types

Modifions une seule ligne de la version précédente.

Nous allons changer seulement cet extrait, les paramètres de la fonction, de :

  TF_Operation** return_opers;
  int num_return_opers;
  TF_ImportGraphDefResultsReturnOperations(results, &num_return_opers,
                                           &return_opers);
  ASSERT_EQ(1, num_return_opers);
  EXPECT_EQ(scalar2, return_opers[0]);  // not remapped

  TF_DeleteImportGraphDefResults(results);

  // Import again, with control dependencies, into the same graph.
  TF_DeleteImportGraphDefOptions(opts);

        }
    }


    /**
     * Resolve an array of SIDs using a cache and at most one MSRPC request.
     * <p>
     * This method will attempt
     * to resolve SIDs using a cache and cache the results of any SIDs that
     * required resolving with the authority. SID cache entries are currently not
     * expired because under normal circumstances SID information never changes.
     *
     * @param authorityServerName

     * unsigned long. This is useful for detecting overflow while parsing a string representation of
     * a number. Does not verify whether supplied radix is valid, passing an invalid radix will give
     * undefined results or an ArrayIndexOutOfBoundsException.
     */
    static boolean overflowInParse(long current, int digit, int radix) {
      if (current >= 0) {
        if (current < maxValueDivs[radix]) {
          return false;

			continue
		}
		diskCount++
	}
	return diskCount
}

// hashOrder - hashes input key to return consistent
// hashed integer slice. Returned integer order is salted
// with an input key. This results in consistent order.
// NOTE: collisions are fine, we are not looking for uniqueness
// in the slices returned.
func hashOrder(key string, cardinality int) []int {
	if cardinality <= 0 {

errors.not_found_on_file_system=Not Found: {0}
errors.could_not_open_on_system=Could not open {0}. <br/>Please check if the file is associated with an application.
errors.result_size_exceeded=No more results could be displayed.
errors.target_file_does_not_exist={0} file does not exist.
errors.failed_to_delete_file=Failed to delete {0} file.
errors.docid_not_found=Not found Doc ID:{0}