DefaultModuleIdentifier.newId('group3', 'name3'), constraint('1.0'), factory.of(attr, "val1"), [])

        when:
        byte[] result1 = toBytes(selector1, serializer)
        byte[] result2 = toBytes(selector2, serializer)
        byte[] result3 = toBytes(selector3, serializer)

        then:
        result2.length == result1.length // different attributes
        result3.length < result1.length // already seen

	t.Parallel()

	// needs to be large to force allocations so we pick a random value between [1024, 2048]
	size := utilrand.IntnRange(1024, 2048+1)

	t.Run("toBytes semantics", func(t *testing.T) {
		t.Parallel()

		s := utilrand.String(size)
		b := toBytes(s)
		if len(b) != size {
			t.Errorf("unexpected length: %d", len(b))
		}
		if cap(b) != size {
			t.Errorf("unexpected capacity: %d", cap(b))
		}

		b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
			b.AddBytes(toBytes(k))
		})
		b.AddUint16LengthPrefixed(func(b *cryptobyte.Builder) {
			b.AddBytes(annotations[k])
		})
	}

	return b.Bytes()
}

// toBytes performs unholy acts to avoid allocations
func toBytes(s string) []byte {
	// unsafe.StringData is unspecified for the empty string, so we provide a strict interpretation

						RxBytes: toP(1),
						TxBytes: toP(10),
					},
					Interfaces: []statsapi.InterfaceStats{
						{
							Name:    "test",
							RxBytes: toP(1),

							TxBytes: toP(10),
						},
					},
				},
				"c2": {
					Time: v1.Time{},
					InterfaceStats: statsapi.InterfaceStats{
						Name:    "test2",
						RxBytes: toP(2),
						TxBytes: toP(20),
					},

	cinfo.Stats[0].Network = &cadvisorapiv2.NetworkStats{
		Interfaces: []cadvisorapiv1.InterfaceStats{{
			Name:     "eth0",
			RxBytes:  0,
			RxErrors: 0,
			TxBytes:  0,
			TxErrors: 0,
		}, {
			Name:     "cbr0",
			RxBytes:  0,
			RxErrors: 0,
			TxBytes:  0,
			TxErrors: 0,
		}},
	}
	return cinfo
}

Inversement, dans la plupart des cas vous pourrez juste envoyer l'objet récupéré de la base de données **directement au client**

Avec **FastAPI** vous aurez toutes les fonctionnalités de **Pydantic**  (comme FastAPI est basé sur Pydantic pour toutes les manipulations de données):

* **Pas de prise de tête**:
    * Pas de nouveau langage de définition de schéma à apprendre.

     */
    @JvmField
    val FORM = "multipart/form-data".toMediaType()

    private val COLONSPACE = byteArrayOf(':'.code.toByte(), ' '.code.toByte())
    private val CRLF = byteArrayOf('\r'.code.toByte(), '\n'.code.toByte())
    private val DASHDASH = byteArrayOf('-'.code.toByte(), '-'.code.toByte())

    /**
     * Appends a quoted-string to a StringBuilder.
     *

private fun isMappedIpv4Address(address: ByteArray): Boolean {
  if (address.size != 16) return false

  for (i in 0 until 10) {
    if (address[i] != 0.toByte()) return false
  }

  if (address[10] != 255.toByte()) return false
  if (address[11] != 255.toByte()) return false

  return true
}

/** Encodes an IPv4 address in canonical form according to RFC 4001. */

	Snd_wnd             uint32
	Snd_sbbytes         uint32
	Rcv_wnd             uint32
	Rttcur              uint32
	Srtt                uint32
	Rttvar              uint32
	Txpackets           uint64
	Txbytes             uint64
	Txretransmitbytes   uint64
	Rxpackets           uint64
	Rxbytes             uint64
	Rxoutoforderbytes   uint64
	Txretransmitpackets uint64
}

const (

	Snd_wnd             uint32
	Snd_sbbytes         uint32
	Rcv_wnd             uint32
	Rttcur              uint32
	Srtt                uint32
	Rttvar              uint32
	Txpackets           uint64
	Txbytes             uint64
	Txretransmitbytes   uint64
	Rxpackets           uint64
	Rxbytes             uint64
	Rxoutoforderbytes   uint64
	Txretransmitpackets uint64
}

const (