if (outputFile.exists()) {
                outputFile.delete();
            }
        }
    }

    // Test variable replacement logic without triggering component dependencies
    public void test_variable_replacement_logic() throws Exception {
        // Test the variable replacement logic directly
        final List<String> commands =

In that case, you can simply swap the standard `dataclasses` with `pydantic.dataclasses`, which is a drop-in replacement:

{* ../../docs_src/dataclasses/tutorial003.py hl[1,5,8:11,14:17,23:25,28] *}

1. We still import `field` from standard `dataclasses`.

2. `pydantic.dataclasses` is a drop-in replacement for `dataclasses`.

3. The `Author` dataclass includes a list of `Item` dataclasses.

}

// ToValidUTF8 treats s as UTF-8-encoded bytes and returns a copy with each run of bytes
// representing invalid UTF-8 replaced with the bytes in replacement, which may be empty.
func ToValidUTF8(s, replacement []byte) []byte {
	b := make([]byte, 0, len(s)+len(replacement))
	invalid := false // previous byte was from an invalid UTF-8 sequence
	for i := 0; i < len(s); {
		c := s[i]
		if c < utf8.RuneSelf {
			i++

        public ContentTransformer(String name) {
            this.name = name;
        }

        public void addTransformationRule(String pattern, String replacement) {
            transformationRules.put(pattern, replacement);
        }

        @Override
        public ResultData transform(ResponseData responseData) {
            if (responseData == null) {
                return null;

A similar process would apply to any other ASGI server program.

/// tip

By adding the `standard`, Uvicorn will install and use some recommended extra dependencies.

That including `uvloop`, the high-performance drop-in replacement for `asyncio`, that provides the big concurrency performance boost.

When you install FastAPI with something like `pip install "fastapi[standard]"` you already get `uvicorn[standard]` as well.

///

   * overflow a {@code long}, so you can just write {@code (long) a + b}.
   *
   * @throws ArithmeticException if {@code a + b} overflows in signed {@code long} arithmetic
   */
  @InlineMe(replacement = "Math.addExact(a, b)")
  public static long checkedAdd(long a, long b) {
    return Math.addExact(a, b);
  }

  /**
   * Returns the difference of {@code a} and {@code b}, provided it does not overflow.

        // Add rule4 which matches
        ruleManager.addRule(rule4);
        matched = ruleManager.getRule(responseData);
        assertEquals("rule4", matched.getRuleId());
    }

    /**
     * Test rule replacement scenario
     */
    public void test_ruleReplacement() {
        TestRule oldRule = new TestRule("rule1", false);
        TestRule newRule = new TestRule("rule1", true); // Same ID, different behavior

  }

  /**
   * @deprecated Provided only to satisfy the {@link Predicate} interface; use {@link #mightContain}
   *     instead.
   */
  @InlineMe(replacement = "this.mightContain(input)")
  @Deprecated
  @Override
  public boolean apply(@ParametricNullness T input) {
    return mightContain(input);
  }

  /**

	rinfo.ReplicationAction = rAction
	// use core client to avoid doing multipart on PUT
	c := &minio.Core{Client: tgt.Client}
	if rAction != replicateAll {
		// replicate metadata for object tagging/copy with metadata replacement
		srcOpts := minio.CopySrcOptions{
			Bucket:    tgt.Bucket,
			Object:    object,
			VersionID: objInfo.VersionID,
		}
		dstOpts := minio.PutObjectOptions{
			Internal: minio.AdvancedPutOptions{