
    9hlq                     8   S SK r S SKrS SKrS SKrS SKrS SKJr  S SKJrJ	r	J
r
Jr  S SKJrJrJr  S SKJr  S SKJr  S SKJr  S SKJr  S S	KJrJrJrJr  S
SKJr  S
SKJ r   S
SK!J"r"  \RF                  " \$5      r%\&" 5       r'\" 5       r( " S S5      r) " S S5      r*g)    N)AIOKafkaClient)has_gziphas_lz4
has_snappyhas_zstd)IllegalOperationMessageSizeTooLargeErrorUnsupportedVersionError)DefaultPartitioner)DefaultRecordBatch)LegacyRecordBatchBuilder)TopicPartition)INTEGER_MAX_VALUEcommit_structure_validatecreate_taskget_running_loop   )MessageAccumulator)Sender)TransactionManagerc                   h   \ rS rSrSrSr\\R                  4\	\R                  4\\R                  4\\R                  4S.rSrSrSSSSSS	\SSSS
\SSSSSSSSSSSSSSSS.S jr\4S jrS rS rS rS rS rS r     S)S jr     S)S jrS rS r S  r!S! r"S" r#S# r$S$ r%S% r&S& r'S' r(S(r)g)*AIOKafkaProducer%   a!  A Kafka client that publishes records to the Kafka cluster.

The producer consists of a pool of buffer space that holds records that
haven't yet been transmitted to the server as well as a background task
that is responsible for turning these records into requests and
transmitting them to the cluster.

The :meth:`send` method is asynchronous. When called it adds the record to a
buffer of pending record sends and immediately returns. This allows the
producer to batch together individual records for efficiency.

The `acks` config controls the criteria under which requests are considered
complete. The ``all`` setting will result in waiting for all replicas to
respond, the slowest but most durable setting.

The `key_serializer` and `value_serializer` instruct how to turn the key and
value objects the user provides into :class:`bytes`.

Arguments:
    bootstrap_servers (str, list(str)): a ``host[:port]`` string or list of
        ``host[:port]`` strings that the producer should contact to
        bootstrap initial cluster metadata. This does not have to be the
        full node list.  It just needs to have at least one broker that will
        respond to a Metadata API Request. Default port is 9092. If no
        servers are specified, will default to ``localhost:9092``.
    client_id (str): a name for this client. This string is passed in
        each request to servers and can be used to identify specific
        server-side log entries that correspond to this client.
        Default: ``aiokafka-producer-#`` (appended with a unique number
        per instance)
    key_serializer (Callable): used to convert user-supplied keys to bytes
        If not :data:`None`, called as ``f(key),`` should return
        :class:`bytes`.
        Default: :data:`None`.
    value_serializer (Callable): used to convert user-supplied message
        values to :class:`bytes`. If not :data:`None`, called as
        ``f(value)``, should return :class:`bytes`.
        Default: :data:`None`.
    acks (Any): one of ``0``, ``1``, ``all``. The number of acknowledgments
        the producer requires the leader to have received before considering a
        request complete. This controls the durability of records that are
        sent. The following settings are common:

        * ``0``: Producer will not wait for any acknowledgment from the server
          at all. The message will immediately be added to the socket
          buffer and considered sent. No guarantee can be made that the
          server has received the record in this case, and the retries
          configuration will not take effect (as the client won't
          generally know of any failures). The offset given back for each
          record will always be set to -1.
        * ``1``: The broker leader will write the record to its local log but
          will respond without awaiting full acknowledgement from all
          followers. In this case should the leader fail immediately
          after acknowledging the record but before the followers have
          replicated it then the record will be lost.
        * ``all``: The broker leader will wait for the full set of in-sync
          replicas to acknowledge the record. This guarantees that the
          record will not be lost as long as at least one in-sync replica
          remains alive. This is the strongest available guarantee.

        If unset, defaults to ``acks=1``. If `enable_idempotence` is
        :data:`True` defaults to ``acks=all``
    compression_type (str): The compression type for all data generated by
        the producer. Valid values are ``gzip``, ``snappy``, ``lz4``, ``zstd``
        or :data:`None`.
        Compression is of full batches of data, so the efficacy of batching
        will also impact the compression ratio (more batching means better
        compression). Default: :data:`None`.
    max_batch_size (int): Maximum size of buffered data per partition.
        After this amount :meth:`send` coroutine will block until batch is
        drained.
        Default: 16384
    linger_ms (int): The producer groups together any records that arrive
        in between request transmissions into a single batched request.
        Normally this occurs only under load when records arrive faster
        than they can be sent out. However in some circumstances the client
        may want to reduce the number of requests even under moderate load.
        This setting accomplishes this by adding a small amount of
        artificial delay; that is, if first request is processed faster,
        than `linger_ms`, producer will wait ``linger_ms - process_time``.
        Default: 0 (i.e. no delay).
    partitioner (Callable): Callable used to determine which partition
        each message is assigned to. Called (after key serialization):
        ``partitioner(key_bytes, all_partitions, available_partitions)``.
        The default partitioner implementation hashes each non-None key
        using the same murmur2 algorithm as the Java client so that
        messages with the same key are assigned to the same partition.
        When a key is :data:`None`, the message is delivered to a random partition
        (filtered to partitions with available leaders only, if possible).
    max_request_size (int): The maximum size of a request. This is also
        effectively a cap on the maximum record size. Note that the server
        has its own cap on record size which may be different from this.
        This setting will limit the number of record batches the producer
        will send in a single request to avoid sending huge requests.
        Default: 1048576.
    metadata_max_age_ms (int): The period of time in milliseconds after
        which we force a refresh of metadata even if we haven't seen any
        partition leadership changes to proactively discover any new
        brokers or partitions. Default: 300000
    request_timeout_ms (int): Produce request timeout in milliseconds.
        As it's sent as part of
        :class:`~aiokafka.protocol.produce.ProduceRequest` (it's a blocking
        call), maximum waiting time can be up to ``2 *
        request_timeout_ms``.
        Default: 40000.
    retry_backoff_ms (int): Milliseconds to backoff when retrying on
        errors. Default: 100.
    api_version (str): specify which kafka API version to use.
        If set to ``auto``, will attempt to infer the broker version by
        probing various APIs. Default: ``auto``
    security_protocol (str): Protocol used to communicate with brokers.
        Valid values are: ``PLAINTEXT``, ``SSL``, ``SASL_PLAINTEXT``,
        ``SASL_SSL``. Default: ``PLAINTEXT``.
    ssl_context (ssl.SSLContext): pre-configured :class:`~ssl.SSLContext`
        for wrapping socket connections. Directly passed into asyncio's
        :meth:`~asyncio.loop.create_connection`. For more
        information see :ref:`ssl_auth`.
        Default: :data:`None`
    connections_max_idle_ms (int): Close idle connections after the number
        of milliseconds specified by this config. Specifying :data:`None` will
        disable idle checks. Default: 540000 (9 minutes).
    enable_idempotence (bool): When set to :data:`True`, the producer will
        ensure that exactly one copy of each message is written in the
        stream. If :data:`False`, producer retries due to broker failures,
        etc., may write duplicates of the retried message in the stream.
        Note that enabling idempotence acks to set to ``all``. If it is not
        explicitly set by the user it will be chosen. If incompatible
        values are set, a :exc:`ValueError` will be thrown.
        New in version 0.5.0.
    sasl_mechanism (str): Authentication mechanism when security_protocol
        is configured for ``SASL_PLAINTEXT`` or ``SASL_SSL``. Valid values
        are: ``PLAIN``, ``GSSAPI``, ``SCRAM-SHA-256``, ``SCRAM-SHA-512``,
        ``OAUTHBEARER``.
        Default: ``PLAIN``
    sasl_plain_username (str): username for SASL ``PLAIN`` authentication.
        Default: :data:`None`
    sasl_plain_password (str): password for SASL ``PLAIN`` authentication.
        Default: :data:`None`
    sasl_oauth_token_provider (:class:`~aiokafka.abc.AbstractTokenProvider`):
        OAuthBearer token provider instance.
        Default: :data:`None`

Note:
    Many configuration parameters are taken from the Java client:
    https://kafka.apache.org/documentation.html#producerconfigs
r   )gzipsnappylz4zstdN	localhosti i@  autoi @  i   d   	PLAINTEXTi`= Fi`  PLAINkafka)loopbootstrap_servers	client_idmetadata_max_age_msrequest_timeout_msapi_versionackskey_serializervalue_serializercompression_typemax_batch_sizepartitionermax_request_size	linger_msretry_backoff_mssecurity_protocolssl_contextconnections_max_idle_msenable_idempotencetransactional_idtransaction_timeout_mssasl_mechanismsasl_plain_passwordsasl_plain_usernamesasl_kerberos_service_namesasl_kerberos_domain_namesasl_oauth_token_providerc          
         Uc  [        5       nO[        R                  " S[        SS9  UR	                  5       (       a/  [
        R                  " [        R                  " S5      5      U l	        Xl
        USSSS[        4;  a  [        S5      eU
S	;  a  [        S
5      eU
(       a.  U R                  U
   u  nnU" 5       (       d  [        SU
 S35      eOSnUb  SnO[        nU(       a3  U[        L a  SnOUS;  a  [        SU S35      e[!        UU5      U l        OS U l        U[        L a  SnOUS:X  a  Sn[$        =R&                  S-  sl        Uc  S[$        R&                   3nXl        Xl        Xl        Xl        Xl        XPl        [5        S&0 SU_SU_SU_SU_SU_SU_SU_SU_SU_SU_SU_SU_SU_SU_S U_S!U_6U l        U R6                  R8                  U l        [=        U R:                  UUU R2                  S"-  U R"                  US#9U l        [A        U R6                  UU R"                  UUU R>                  US$9U l!        S%U l"        g )'NzOThe loop argument is deprecated since 0.7.1, and scheduled for removal in 0.9.0   )
stacklevelr   r   allzInvalid ACKS parameter)r   r   r   r   NzInvalid compression type!zCompression library for z
 not foundT)rC   rB   zacks=z) not supported if enable_idempotence=Truezaiokafka-producer-r$   r%   r&   r'   r(   r2   r)   r3   r4   r5   r9   r;   r:   r<   r=   r>     )txn_managerr$   )r*   rE   r2   r1   message_accumulatorr(   F )#r   warningswarnDeprecationWarning	get_debug	tracebackextract_stacksys	_getframe_source_traceback_loop_missing
ValueError_COMPRESSORSRuntimeErrorr   r   _txn_managerr   _PRODUCER_CLIENT_ID_SEQUENCE_key_serializer_value_serializer_compression_type_partitioner_max_request_size_request_timeout_msr   clientcluster	_metadatar   _message_accumulatorr   _sender_closed)selfr$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   checkercompression_attrss                                 _C:\Suresh\moveshuttle\MDcreated\moveengine\venv\Lib\site-packages\aiokafka/producer/producer.py__init__AIOKafkaProducer.__init__   s   > <#%DMM5"	 >>%.%<%<S]]1=M%ND"
1b%22566#JJ899)-):):;K)L&G&99"./?.@
K  
 !"'!%%6"x[( D6!JK  !3 "8!D !%D8DU]D55:5$%5%R%R$ST   .!1!1'!1#5 $ 

/
  
 !4	

  2
 .
 $
 0
 $
 %<
 *
 !4
 !4
 (B
 '@
  '@!
$ ,,$6NN$$t+))%
! KK))- $ 9 91
     c                     U R                   SL aV  UR                  SU < 3[        U S9  U SS.nU R                  b  U R                  US'   U R                  R                  U5        g g )NFzUnclosed AIOKafkaProducer )sourcezUnclosed AIOKafkaProducer)producermessagesource_traceback)rc   rI   ResourceWarningrP   rQ   call_exception_handler)rd   	_warningscontexts      rg   __del__AIOKafkaProducer.__del__K  st    <<5 NN,TH5   !6G %%1.2.D.D*+JJ--g6 !rj   c                   #    U R                   [        5       L d   S5       e[        R                  S5        U R                  R                  5       I Sh  vN   U R                  S:X  a"  U R                  R                  S:  d   S5       eO1U R                  S:X  a!  U R                  R                  S:  d   S	5       eU R                  b%  U R                  R                  S
:  a  [        S5      eU R                  R                  5       I Sh  vN   U R                  R                  U R                  R                  5        U R                  R                  S:  a  SOSU l        [        R                  S5        g GN$ No7f)z1Connect to Kafka cluster and check server versionz8Please create objects with the same loop as running withzStarting the Kafka producerNr   )r      r@   z#LZ4 Requires >= Kafka 0.8.2 Brokersr   )r@   r   r   z$Zstd Requires >= Kafka 2.1.0 Brokersr      zDIdempotent producer available only for Broker version 0.11 and above)r   
   r   r   zKafka producer started)rQ   r   logdebugr^   	bootstraprZ   r)   rV   r
   rb   startra   set_api_version_producer_magicrd   s    rg   r~   AIOKafkaProducer.startZ  sG     JJ*,,	FE	F,		/0kk##%%%!!U*;;**i7 57 ##v-;;**i7 67 (T[[-D-Dw-N) 
 ll  """!!11$++2I2IJ$(KK$;$;g$Eq1		*+) 	&" 	#s&   AE<E7B6E<
E:A-E<:E<c                 T   #    U R                   R                  5       I Sh  vN   g N7f)z9Wait until all batches are Delivered and futures resolvedN)ra   flushr   s    rg   r   AIOKafkaProducer.flushv  s     ''--///s   (&(c                   #    U R                   (       a  gSU l         U R                  b  U R                  R                  b  [        R                  " [        U R                  R                  5       5      U R                  R                  /[        R                  S9I Sh  vN   U R                  R                  5       I Sh  vN   U R                  R                  5       I Sh  vN   [        R                  S5        g N^ N> N7f)zAFlush all pending data and close all connections to kafka clusterNT)return_whenzThe Kafka producer has closed.)rc   rb   sender_taskasynciowaitr   ra   closeFIRST_COMPLETEDr^   r{   r|   r   s    rg   stopAIOKafkaProducer.stopz  s     << <<#(@(@(L,, 9 9 ? ? ABLL,, $33   ,,$$&&&kk!!!		23 '!s6   BDC<!D?C> !D!D "D>D Dc                 T   #    U R                   R                  U5      I Sh  vN $  N7f)z2Returns set of all known partitions for the topic.N)r^   _wait_on_metadata)rd   topics     rg   partitions_forAIOKafkaProducer.partitions_for  s      [[2259999s   (&(c                 J   U R                   c  UnOU R                  U5      nU R                  c  UnOU R                  U5      n[        R                  " U R                  5      nUb  U[        U5      -  nUb  U[        U5      -  nX`R                  :  a  [        SU-  5      eXE4$ )NzThe message is %d bytes when serialized which is larger than the maximum request size you have configured with the max_request_size configuration)rX   rY   r   record_overheadr   lenr\   r	   )rd   r   keyvalueserialized_keyserialized_valuemessage_sizes          rg   
_serializeAIOKafkaProducer._serialize  s    ' N!11#6N!!)$#55e</??@T@TU%C//L'C 011L000*24@A  //rj   c                    Ub/  US:  d   eX R                   R                  U5      ;   d   S5       eU$ [        U R                   R                  U5      5      n[        U R                   R                  U5      5      nU R	                  XWU5      $ )Nr   zUnrecognized partition)r`   partitions_for_topiclistavailable_partitions_for_topicr[   )	rd   r   	partitionr   r   r   r   all_partitions	availables	            rg   
_partitionAIOKafkaProducer._partition  s      >!> C C!  ('(  dnnAA%HIFFuMN	  KKrj   c           	        #    Uc!  U R                   R                  S:  d   S5       eUc
  Uc   S5       eU R                   R                  U5      I Sh  vN   U R                  bC  U R                  nUR                  b*  U R                  R                  5       (       d  [        S5      eUb&  U R                   R                  S:  a  [        S5      eO/ nU R                  XU5      u  pU R                  XX2X5      n[        X5      n
[        R                  SX2U
5        U R                  R                  U
UU	U R                  S	-  UUS
9I Sh  vN nU$  N N7f)a  Publish a message to a topic.

Arguments:
    topic (str): topic where the message will be published
    value (Optional): message value. Must be type :class:`bytes`, or be
        serializable to :class:`bytes` via configured `value_serializer`. If
        value is :data:`None`, key is required and message acts as a
        ``delete``.

        See `Kafka compaction documentation
        <https://kafka.apache.org/documentation.html#compaction>`__ for
        more details. (compaction requires kafka >= 0.8.1)
    partition (int, Optional): optionally specify a partition. If not
        set, the partition will be selected using the configured
        `partitioner`.
    key (Optional): a key to associate with the message. Can be used to
        determine which partition to send the message to. If partition
        is :data:`None` (and producer's partitioner config is left as default),
        then messages with the same key will be delivered to the same
        partition (but if key is :data:`None`, partition is chosen randomly).
        Must be type :class:`bytes`, or be serializable to bytes via configured
        `key_serializer`.
    timestamp_ms (int, Optional): epoch milliseconds (from Jan 1 1970
        UTC) to use as the message timestamp. Defaults to current time.
    headers (Optional): Kafka headers to be included in the message using
        the format ``[("key", b"value")]``. Iterable of tuples where key
        is a normal string and value is a byte string.

Returns:
    asyncio.Future: object that will be set when message is
    processed

Raises:
    ~aiokafka.errors.KafkaTimeoutError: if we can't schedule this record
        (pending buffer is full) in up to `request_timeout_ms`
        milliseconds.

Note:
    The returned future will wait based on `request_timeout_ms`
    setting. Cancelling the returned future **will not** stop event
    from being sent, but cancelling the :meth:`send` coroutine itself
    **will**.
N)r   rw   r   z$Null messages require kafka >= 0.8.1zNeed at least one: key or value,Can't send messages while not in transactionrx   z'Headers not supported before Kafka 0.11zSending (key=%s value=%s) to %srD   )timestamp_msheaders)r^   r)   r   rV   r7   is_in_transactionr   r
   r   r   r   r{   r|   ra   add_messager]   )rd   r   r   r   r   r   r   rE   	key_bytesvalue_bytestpfuts               rg   sendAIOKafkaProducer.send  sj    h  DKK$;$;y$H 	
2	
H MckU4UU2 kk++E222 (++K,,8));;==&'UVV{{&&0-.WXX 1 G!%U!C	OOc)
	 E-		3SD--99$$t+% : 
 
 
E 	34
s%   AEEC6E	E
EEc                 \   #    U R                  XX4XV5      I Sh  vN nUI Sh  vN $  N N7f)z0Publish a message to a topic and wait the resultN)r   )rd   r   r   r   r   r   r   futures           rg   send_and_waitAIOKafkaProducer.send_and_wait  s-      yys|UU| Vs   ,(	,*,,c                 ^    U R                   R                  U R                  U R                  S9$ )zCreate and return an empty :class:`.BatchBuilder`.

The batch is not queued for send until submission to :meth:`send_batch`.

Returns:
    BatchBuilder: empty batch to be filled and submitted by the caller.
)r+   r,   )ra   create_builderrX   rY   r   s    rg   create_batchAIOKafkaProducer.create_batch$  s3     ((77//$BXBX 8 
 	
rj   c                  #    U R                   R                  U5      I Sh  vN   U R                  X#SSSS5      nU R                  bC  U R                  nUR                  b*  U R                  R                  5       (       d  [        S5      e[        X#5      n[        R                  SU5        U R                  R                  XU R                  S-  5      I Sh  vN nU$  N N7f)aC  Submit a BatchBuilder for publication.

Arguments:
    batch (BatchBuilder): batch object to be published.
    topic (str): topic where the batch will be published.
    partition (int): partition where this batch will be published.

Returns:
    asyncio.Future: object that will be set when the batch is
        delivered.
Nr   zSending batch to %srD   )r^   r   r   rV   r7   r   r   r   r{   r|   ra   	add_batchr]   )rd   batchr   r   rE   r   r   s          rg   
send_batchAIOKafkaProducer.send_batch0  s      kk++E222OOEdD$M	 (++K,,8));;==&'UVVE-		',00::t//$6
 
 % 	3
s"   C#CB6C#C!C#!C#c                 b    U R                   b  U R                   R                  c  [        S5      eg )Nz8You need to configure transaction_id to use transactions)rV   r7   r   r   s    rg   _ensure_transactional&AIOKafkaProducer._ensure_transactionalQ  s5    $(9(9(J(J(R"J  )Srj   c                 $  #    U R                  5         [        R                  SU R                  R                  5        [
        R                  " U R                  R                  5       5      I S h  vN   U R                  R                  5         g  N7f)Nz%Beginning a new transaction for id %s)	r   r{   r|   rV   r7   r   shieldwait_for_pidbegin_transactionr   s    rg   r   "AIOKafkaProducer.begin_transactionW  sh     ""$		3T5F5F5W5W	
 nnT..;;=>>>++- 	?s   A,B.B/ Bc                 $  #    U R                  5         [        R                  SU R                  R                  5        U R                  R                  5         [        R                  " U R                  R                  5       5      I S h  vN   g  N7f)Nz Committing transaction for id %s)	r   r{   r|   rV   r7   committing_transactionr   r   wait_for_transaction_endr   s    rg   commit_transaction#AIOKafkaProducer.commit_transaction_  sj     ""$		.0A0A0R0R	
 	002nn668
 	
 	
   BBB	Bc                 $  #    U R                  5         [        R                  SU R                  R                  5        U R                  R                  5         [        R                  " U R                  R                  5       5      I S h  vN   g  N7f)NzAborting transaction for id %s)	r   r{   r|   rV   r7   aborting_transactionr   r   r   r   s    rg   abort_transaction"AIOKafkaProducer.abort_transactioni  sf     ""$		2D4E4E4V4VW..0nn668
 	
 	
r   c                     [        U 5      $ )zStart a transaction context)TransactionContextr   s    rg   transactionAIOKafkaProducer.transactionq  s     "$''rj   c                   #    U R                  5         U R                  R                  5       (       d  [        S5      eU(       a  [	        U[
        5      (       d  [        U5      e[        U5      n[        R                  SUU5        U R                  R                  X25      n[        R                  " U5      I S h  vN   g  N7f)Nz"Not in the middle of a transactionz<Begin adding offsets %s for consumer group %s to transaction)r   rV   r   r   
isinstancestrrS   r   r{   r|   add_offsets_to_txnr   r   )rd   offsetsgroup_idformatted_offsetsr   s        rg   send_offsets_to_transaction,AIOKafkaProducer.send_offsets_to_transactionv  s     ""$  2244"#GHHz(C88X&& 6g>		J	

 223DOnnS!!!s   B8C:C ;Cc                 B   #    U R                  5       I S h  vN   U $  N7fN)r~   r   s    rg   
__aenter__AIOKafkaProducer.__aenter__  s     jjl 	s   c                 @   #    U R                  5       I S h  vN   g  N7fr   )r   )rd   exc_typeexctbs       rg   	__aexit__AIOKafkaProducer.__aexit__  s     iiks   )rc   rZ   rX   rQ   r\   ra   r`   r[   r   r]   rb   rP   rV   rY   r^   )NNNNN)*__name__
__module____qualname____firstlineno____doc__rW   r   r   
CODEC_GZIPr   CODEC_SNAPPYr   	CODEC_LZ4r   
CODEC_ZSTDrT   rc   rP   rR   _DEFAULT_PARTITIONERrh   rH   rt   r~   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   __static_attributes__rG   rj   rg   r   r   %   sG   Qf $%  -8891>>?+556-889	L G
 %" ( % & $  #*"&"&;BL !) 7,804*:00L" \B 

B.

(
"(rj   r   c                   &    \ rS rSrS rS rS rSrg)r   i  c                     Xl         g r   	_producer)rd   rm   s     rg   rh   TransactionContext.__init__  s    !rj   c                 V   #    U R                   R                  5       I S h  vN   U $  N7fr   )r   r   r   s    rg   r   TransactionContext.__aenter__  s%     nn..000 	1s   )')c                    #    UbM  U R                   R                  R                  5       (       a  g U R                   R                  5       I S h  vN   g U R                   R	                  5       I S h  vN   g  N( N7fr   )r   rV   is_fatal_errorr   r   )rd   r   	exc_valuerL   s       rg   r   TransactionContext.__aexit__  s]      ~~**99;;..22444..33555 55s$   AA:A6"A:0A81A:8A:r   N)r   r   r   r   rh   r   r   r   rG   rj   rg   r   r     s    "6rj   r   )+r   loggingrN   rL   rH   aiokafka.clientr   aiokafka.codecr   r   r   r   aiokafka.errorsr   r	   r
   aiokafka.partitionerr   aiokafka.record.default_recordsr   aiokafka.record.legacy_recordsr   aiokafka.structsr   aiokafka.utilr   r   r   r   rF   r   senderr   transaction_managerr   	getLoggerr   r{   objectrR   r   r   r   rG   rj   rg   <module>r     s      
   * B B 
 4 > C +  4  3!8 *+ j	 j	Z6 6rj   