}
        return versions
    }


    private
    fun String.escape() = replace("<", "&lt;").replace(">", "&gt;")
}


private
typealias Version = String


private
data class IncubatingDescription(val name: String, val sourceRelativePath: Path, val lineNumber: Int)


private
typealias VersionsToIncubating = Map<Version, MutableSet<IncubatingDescription>>


private

    }

    /**
     * Sends a DCERPC fragment to the remote endpoint
     * @param buf the buffer containing the fragment
     * @param off the offset into the buffer
     * @param length the length of data to send
     * @param isDirect whether to use direct transmission
     * @throws IOException if an I/O error occurs
     */

///

## 导入 Pydantic 的 `BaseModel` { #import-pydantics-basemodel }

从 `pydantic` 中导入 `BaseModel`：

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

## 创建数据模型 { #create-your-data-model }

把数据模型声明为继承 `BaseModel` 的类。

使用 Python 标准类型声明所有属性：

{* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}

与声明查询参数一样，包含默认值的模型属性是可选的，否则就是必选的。把默认值设为 `None` 可使其变为可选。

    keyToKeyList = CompactLinkedHashMap.create();
    int size = stream.readInt();
    for (int i = 0; i < size; i++) {
      @SuppressWarnings("unchecked") // reading data stored by writeObject
      K key = (K) stream.readObject();
      @SuppressWarnings("unchecked") // reading data stored by writeObject
      V value = (V) stream.readObject();
      put(key, value);
    }
  }

        dstOut.enc_ndr_long(1); // Non-null pointer for totalentries
        totalentries.encode(dstOut); // Encode the totalentries

        dstOut.enc_ndr_long(0); // Simulate retval

        // Use the encoded data for decoding
        NdrBuffer srcOut = new NdrBuffer(encodeBufferOut, 0);
        decodedEnumEx.decode_out(srcOut);

        assertEquals(0, decodedEnumEx.retval);

		t.Parallel()
		if !generatesZip64(t, gen(0xffff)) {
			t.Error("expected zip64")
		}
	})
}

// suffixSaver is an io.Writer & io.ReaderAt that remembers the last 0
// to 'keep' bytes of data written to it. Call Suffix to get the
// suffix bytes.
type suffixSaver struct {
	keep  int
	buf   []byte
	start int
	size  int64
}

func (ss *suffixSaver) Size() int64 { return ss.size }

file:/example.com/  s:file p:/example.com/
ftps:/example.com/  s:ftps p:/example.com/
gopher:/example.com/  s:gopher h:example.com p:/
ws:/example.com/  s:ws h:example.com p:/
wss:/example.com/  s:wss h:example.com p:/
data:/example.com/  s:data p:/example.com/
javascript:/example.com/  s:javascript p:/example.com/
mailto:/example.com/  s:mailto p:/example.com/
http:example.com/  s:http h:example.org p:/foo/example.com/

   *
   * <p>The serialization format consists of a 6-byte header (1 byte strategy, 1 byte hash
   * functions, 4 bytes array length) followed by the bit array data (bitSize / 8 bytes).
   */
  public void testBitSizeMatchesSerializationSize() throws Exception {
    int[] expectedInsertionValues = {1, 10, 100, 1000, 10000};
    double[] fppValues = {0.01, 0.03, 0.1};

        }
        return response.getStatus().getStatus();
    }

    /**
     * Calculates the memory size of a document data map.
     * This is useful for monitoring memory usage during indexing operations.
     *
     * @param dataMap the document data as a map of field names to values
     * @return the estimated memory size in bytes
     */

{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}

#### Ein zufälliges Item { #a-random-item }