code: def _write_packet(self, packet, sec=None, usec=None, caplen=None,
                        wirelen=None):
          
          if hasattr(packet, "time"):
              if sec is None:
                  sec = int(packet.time)
                  usec = int(round((packet.time - sec) *
                                   (1000000000 if self.nano else 1000000)))
          if usec is None:
              usec = 0
  
          rawpkt = raw(packet)
          caplen = len(rawpkt) if caplen is None else caplen
  
          if wirelen is None:
              if hasattr(packet, "wirelen"):
                  wirelen = packet.wirelen
          if wirelen is None:
              wirelen = caplen
  
          RawPcapWriter._write_packet(
              self, rawpkt, sec=sec, usec=usec, caplen=caplen, wirelen=wirelen)
docs: Writes a single packet to the pcap file.
  
          :param packet: Packet, or bytes for a single packet
          :type packet: Packet or bytes
          :param sec: time the packet was captured, in seconds since epoch. If
                      not supplied, defaults to now.
          :type sec: int or long
          :param usec: If ``nano=True``, then number of nanoseconds after the
                       second that the packet was captured. If ``nano=False``,
                       then the number of microseconds after the second the
                       packet was captured. If ``sec`` is not specified,
                       this value is ignored.
          :type usec: int or long
          :param caplen: The length of the packet in the capture file. If not
                         specified, uses ``len(raw(packet))``.
          :type caplen: int
          :param wirelen: The length of the packet on the wire. If not
                          specified, tries ``packet.wirelen``, otherwise uses
                          ``caplen``.
          :type wirelen: int
          :returns: None
          :rtype: None