@CheckForNull
  public Range<C> rangeContaining(C value) {
    int index =
        SortedLists.binarySearch(
            ranges,
            Range::lowerBound,
            Cut.belowValue(value),
            Ordering.natural(),
            ANY_PRESENT,
            NEXT_LOWER);
    if (index != -1) {
      Range<C> range = ranges.get(index);
      return range.contains(value) ? range : null;
    }
    return null;
  }

  // Limited priority levels in proportion to their NCS values:
  //
  // NominalCL(i)  = ceil( ServerCL * NCS(i) / sum_ncs )
  // sum_ncs = sum[limited priority level k] NCS(k)
  //
  // Bigger numbers mean a larger nominal concurrency limit,
  // at the expense of every other Limited priority level.
  // This field has a default value of 30.
  // +optional
  optional int32 nominalConcurrencyShares = 1;

  }

  public void testNewIdentityHashSet() {
    Set<Integer> set = Sets.newIdentityHashSet();
    Integer value1 = new Integer(12357);
    Integer value2 = new Integer(12357);
    assertTrue(set.add(value1));
    assertFalse(set.contains(value2));
    assertTrue(set.contains(value1));
    assertTrue(set.add(value2));
    assertEquals(2, set.size());
  }

  @J2ktIncompatible
  @GwtIncompatible // CopyOnWriteArraySet

                            mergedArtifacts.put(conflictId, artifact);
                        }
                    }

                    artifacts = new LinkedHashSet<>(mergedArtifacts.values());
                }

                collectionRequest = new ArtifactResolutionRequest(request);
                collectionRequest.setServers(request.getServers());

///

## Pydanticを使わない方法

  TF_DeleteTensor(t);

  for (int i = 0; i < expected_values.size(); i++) {
    EXPECT_EQ(expected_values[i], actual_values[i])
        << "Mismatch in expected values at (zero-based) index " << i;
  }
}

void CheckRemoteMatMulExecutesOK(TFE_Context* ctx,
                                 const char* remote_device_name,
                                 const char* local_device_name) {

		return
	}
	value, err = strconv.Atoi(stringInt)
	if err != nil {
		return 0, InvalidArgument{
			Bucket: bucket,
			Object: object,
			Err:    fmt.Errorf("Unable to parse %s, value should be an integer", headerName),
		}
	}
	return
}

func parseBoolHeader(bucket, object string, h http.Header, headerName string) (bool, error) {
	value := strings.TrimSpace(h.Get(headerName))
	if value != "" {
		switch value {

///

```Python hl_lines="80-83"
{!> ../../docs_src/security/tutorial003.py!}
```

////

#### Sobre `**user_dict`

`UserInDB(**user_dict)` significa:

*Passe as keys (chaves) e values (valores) de `user_dict` diretamente como argumentos de valor-chave, equivalente a:*

```Python
UserInDB(
    username = user_dict["username"],
    email = user_dict["email"],
    full_name = user_dict["full_name"],

		t.Errorf("UpdateAt should be changed when update values with assign")
	}

	DB.Where(&User{Name: "find or create 4"}).Assign(User{Age: 44}).FirstOrCreate(&user4)
	if user4.Name != "find or create 4" || user4.ID == 0 || user4.Age != 44 {
		t.Errorf("user should be created with search value and assigned attrs")
	}

                            logger.debug("Keep thumbnail: {}", docId);
                        }
                    }
                });

                deleteFileMap.values().forEach(this::deleteFile);
                count += deleteFileMap.size();
            }
        }

        protected void deleteFile(final Path path) {
            try {
                Files.delete(path);