docs: def post_build(self, pkt, pay):
          """
          Apply the previous methods according to the writing cipher type.
          """
          # Compute the length of TLSPlaintext fragment
          hdr, frag = pkt[:5], pkt[5:]
          tmp_len = len(frag)
          hdr = hdr[:3] + struct.pack("!H", tmp_len)
  
          # Compression
          cfrag = self._tls_compress(frag)
          tmp_len = len(cfrag)  # Update the length as a result of compression
          hdr = hdr[:3] + struct.pack("!H", tmp_len)
  
          cipher_type = self.tls_session.wcs.cipher.type
  
          if cipher_type == 'block':
              # Integrity
              mfrag = self._tls_hmac_add(hdr, cfrag)
  
              # Excerpt below better corresponds to TLS 1.1 IV definition,
              # but the result is the same as with TLS 1.2 anyway.
              # if self.version >= 0x0302:
              #    l = self.tls_session.wcs.cipher.block_size
              #    iv = randstring(l)
              #    mfrag = iv + mfrag
  
              # Add padding
              pfrag = self._tls_pad(mfrag)
  
              # Encryption
              if self.version >= 0x0302:
                  # Explicit IV for TLS 1.1 and 1.2
                  tmp_len = self.tls_session.wcs.cipher.block_size
                  iv = randstring(tmp_len)
                  self.tls_session.wcs.cipher.iv = iv
                  efrag = self._tls_encrypt(pfrag)
                  efrag = iv + efrag
              else:
                  # Implicit IV for SSLv3 and TLS 1.0
                  efrag = self._tls_encrypt(pfrag)
  
          elif cipher_type == "stream":
              # Integrity
              mfrag = self._tls_hmac_add(hdr, cfrag)
              # Encryption
              efrag = self._tls_encrypt(mfrag)
  
          elif cipher_type == "aead":
              # Authenticated encryption (with nonce_explicit as header)
              efrag = self._tls_auth_encrypt(cfrag)
  
          if self.len is not None:
              # The user gave us a 'len', let's respect this ultimately
              hdr = hdr[:3] + struct.pack("!H", self.len)
          else:
              # Update header with the length of TLSCiphertext.fragment
              hdr = hdr[:3] + struct.pack("!H", len(efrag))
  
          # Now we commit the pending write state if it has been triggered (e.g.
          # by an underlying TLSChangeCipherSpec or a SSLv2ClientMasterKey). We
          # update nothing if the pwcs was not set. This probably means that
          # we're working out-of-context (and we need to keep the default wcs).
          if self.tls_session.triggered_pwcs_commit:
              if self.tls_session.pwcs is not None:
                  self.tls_session.wcs = self.tls_session.pwcs
                  self.tls_session.pwcs = None
              self.tls_session.triggered_pwcs_commit = False
  
          return hdr + efrag + pay