O'^c@@s dZddlmZddlZddlZddlmZddlmZm Z ddl m Z ddl m Z dd lmZmZmZmZmZdd lmZdd lmZmZdd lmZmZmZmZdd lm Z ddl!m"Z"ddl#m$Z$m%Z%m&Z&m'Z'dddgZ(idd6dd6Z)ej*j+de,Z-ej*j+de,Z.ee/Z0e Z1ie1d6ed6Z2de3fdYZ4e4Z5de3fdYZ6de6fdYZ7de6fdYZ8dZ9d Z:dS(!sB kombu.connection ================ Broker connection and pools. i(tabsolute_importN(tcontextmanager(tcounttcycle(t itemgetter(t exceptionsi(tEmptytrangetstring_tttext_tt LifoQueue(t get_logger(tget_transport_clstsupports_librabbitmq(tcached_propertytretry_over_timet shufflecyclet HashedSeq(t OrderedDict(tlazy(tas_urlt parse_urltquoteturlparset ConnectiontConnectionPoolt ChannelPooltamqptpyamqpt librabbitmqtKOMBU_LOG_CONNECTIONtKOMBU_LOG_CHANNELs round-robintshufflecB@sfeZdZdFZdZdZdFZdFZdFZ dFZ e Z dFZ dFZdFZdFZdZeZdFZdFZZZZZddFdFdFdFe e dFddFdFdFdddFdZdZdZd Zd Zd Zd Zd Z ddZ!dZ"dZ#dZ$dZ%dFdZ&dZ'e'Z(dFdFddddFdZ)dZ*dZ+dZ,dFdFddddFdZ-dFdZ.dZ/dZ0d Z1d!Z2e3d"Z4d#Z5d$Z6e d%e7d&d'd(d)d*d+Z8dFdFd,Z9dFdFd-Z:dFd.Z;dFdFd/Z<dFdFdFdFd0Z=dFdFdFdFd1Z>d2Z?d3Z@d4ZAd5ZBd6ZCd7ZDeEd8ZFeEd9ZGeEd:ZHeEd;ZIeEd<ZJeEd=ZKeLd>ZMd?ZNeLd@ZOeLdAZPeLdBZQeLdCZReEdDZSeEdEZTRS(Gs A connection to the broker. :param URL: Broker URL, or a list of URLs, e.g. .. code-block:: python Connection('amqp://guest:guest@localhost:5672//') Connection('amqp://foo;amqp://bar', failover_strategy='round-robin') Connection('redis://', transport_options={ 'visibility_timeout': 3000, }) import ssl Connection('amqp://', login_method='EXTERNAL', ssl={ 'ca_certs': '/etc/pki/tls/certs/something.crt', 'keyfile': '/etc/something/system.key', 'certfile': '/etc/something/system.cert', 'cert_reqs': ssl.CERT_REQUIRED, }) .. admonition:: SSL compatibility SSL currently only works with the py-amqp, amqplib, and qpid transports. For other transports you can use stunnel. :keyword ssl: Use SSL to connect to the server. Default is ``False``. May not be supported by the specified transport. :keyword transport: Default transport if not specified in the URL. :keyword connect_timeout: Timeout in seconds for connecting to the server. May not be supported by the specified transport. :keyword transport_options: A dict of additional connection arguments to pass to alternate kombu channel implementations. Consult the transport documentation for available options. :keyword heartbeat: Heartbeat interval in int/float seconds. Note that if heartbeats are enabled then the :meth:`heartbeat_check` method must be called regularly, around once per second. .. note:: The connection is established lazily when needed. If you need the connection to be established, then force it by calling :meth:`connect`:: >>> conn = Connection('amqp://') >>> conn.connect() and always remember to close the connection:: >>> conn.release() *Legacy options* These options have been replaced by the URL argument, but are still supported for backwards compatibility: :keyword hostname: Host name/address. NOTE: You cannot specify both the URL argument and use the hostname keyword argument at the same time. :keyword userid: Default user name if not provided in the URL. :keyword password: Default password if not provided in the URL. :keyword virtual_host: Default virtual host if not provided in the URL. :keyword port: Default port if not provided in the URL. t/is round-robint localhosticK@s:|dkrgn|}i |d6|d6|d6|d6|d6|d6|d6|d6| d 6| d 6| d 6}|_|rt|t r|j||d }n|rwd |krwd|kr|j|jd|d }nd||jd  kr0|jdd\|d<|d<|d}|_qw|pBt|j }t |j sj|j t |n||dClose given channel, but ignore connection and channel errors.N(RLtconnection_errorstchannel_errors(RGRg((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytmaybe_close_channel"scC@s}|jj|jr)|j|jn|jryy|jj|jWn!|jtt j fk rlnXd|_ndS(N( RFRMt_default_channelRmt _connectionR*tclose_connectionRktAttributeErrortsocketterrorR0(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt_do_close_self)s   cC@sE|j|jr+d|j_d|_n|jdt|_dS(s;Really close connection, even if part of a connection pool.tclosedN(Rtt _transportR0tclientR`RCRO(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt_close5s      cC@sy|jj}Wndtk rvtj}tj|z)y|jWntjk r`nXWdtj|XnEX||j|jrd|j_ d|_n|j j d|_dS(N( Rvt_collectRqRrtgetdefaulttimeouttsetdefaulttimeoutRxttimeoutRoR0RwRFRM(RGtsocket_timeoutt gc_transportt_timeo((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytcollect>s"        cC@s|jdS(sClose the connection (if open).N(Rx(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytreleaseUsic @sDdfd}tjjdi|||||| S(snEnsure we have a connection to the server. If not retry establishing the connection with the settings specified. :keyword errback: Optional callback called each time the connection can't be established. Arguments provided are the exception raised and the interval that will be slept ``(exc, interval)``. :keyword max_retries: Maximum number of times to retry. If this limit is exceeded the connection error will be re-raised. :keyword interval_start: The number of seconds we start sleeping for. :keyword interval_step: How many seconds added to the interval for each retry. :keyword interval_max: Maximum number of seconds to sleep between each retry. :keyword callback: Optional callback that is called for every internal iteration (1 s) ic@sRj|}|r$t|}nr:||nj|rN|SdS(Ni(tcompletes_cycleR@RS(texct intervalstretriestintervaltround(terrbackRG(s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyton_errorrs ((RRatrecoverable_connection_errors(RGRt max_retriestinterval_startt interval_stept interval_maxtcallbackR((RRGs2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytensure_connectionZs   cC@s#|jr|dt|j StS(s?Return true if the cycle is complete after number of `retries`.i(R;tlenRC(RGR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRscC@s)|jr%|j|jd|_ndS(s2Revive connection after connection re-established.N(RnRmR0(RGt new_channel((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytrevives cC@stjd||dtdS(Ns)Ensure: Operation error: %r. Retry in %sstexc_info(R[RsRC(RGRR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt_default_ensure_callbacks ic @sSf d} dj| _j| _j| _| S(sEnsure operation completes, regardless of any channel/connection errors occurring. Will retry by establishing the connection, and reapplying the function. :param fun: Method to apply. :keyword errback: Optional callback called each time the connection can't be established. Arguments provided are the exception raised and the interval that will be slept ``(exc, interval)``. :keyword max_retries: Maximum number of times to retry. If this limit is exceeded the connection error will be re-raised. :keyword interval_start: The number of seconds we start sleeping for. :keyword interval_step: How many seconds added to the interval for each retry. :keyword interval_max: Maximum number of seconds to sleep between each retry. **Example** This is an example ensuring a publish operation:: >>> from kombu import Connection, Producer >>> conn = Connection('amqp://') >>> producer = Producer(conn) >>> def errback(exc, interval): ... logger.error('Error: %r', exc, exc_info=1) ... logger.info('Retry in %s seconds.', interval) >>> publish = conn.ensure(producer, producer.publish, ... errback=errback, max_retries=3) >>> publish({'hello': 'world'}, routing_key='dest') c @sd}j}j}tjd}xtdD]w}y||SWq7|k rT}|rs| rsndk r|krnjd|ddd_jo|dd}dk rt |d}nj |j } j | j | rG| n|d7}q7|k r}dk r|krnjd|ddo|dq7Xq7WdS(NiRsensure connection error: %rRisensure channel error: %r( Rtrecoverable_channel_errorsthasattrR*RR0R`RoRttmaxRRgR( R^RItgot_connectiont conn_errorst chan_errorsthas_modern_errorsRRtremaining_retriesR( RtfunRRRRtobjt on_reviveRG(s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt_ensuredsH            s %s(ensured)(t__name__t__doc__t __module__( RGRRRRRRRRR(( RRRRRRRRRGs2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytensures )'*  c @sP|g|jdtffdY}|}|j|||S(sDecorator for functions supporting a ``channel`` keyword argument. The resulting callable will retry calling the function if it raises connection or channel related errors. The return value will be a tuple of ``(retval, last_created_channel)``. If a ``channel`` is not provided, then one will be automatically acquired (remember to close it afterwards). See :meth:`ensure` for the full list of supported keyword arguments. Example usage:: channel = connection.channel() try: ret, channel = connection.autoretry(publish_messages, channel) finally: channel.close() tRevivalc@sbeZeddZeddZeddZfdZfdZRS(RRRc@s|dR*tdefault_connection_paramsR#R6R$R%R&R'R(R)R+RAR,R-R<R;(RGRRTtDR#tinfo((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyR s.            cC@st|jS(sGet connection info.(RR(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyR=sc C@s7t|j|j|j|j|j|jt|jS(N( RRTR#R$R%R&R'treprRA(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt __eqhash__Ass**R'R$R%R&R*c C@s|jp d}|jjr<|jr5d|j|fS|jS|jrVd|j|fS|j}||\}}}} } t| ||||t| d| d|S(s*Convert connection parameters to URL form.R"s%s+%stsanitizetmask(R#R*R8R6RRR( RGtinclude_passwordRt getfieldsR#tfieldsR'R$R%tvhostR*((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytas_uriFs    cC@st|||S(sJPool of connections. See :class:`ConnectionPool`. :keyword limit: Maximum number of active connections. Default is no limit. :keyword preload: Number of connections to preload when the pool is created. Default is 0. *Example usage*:: >>> connection = Connection('amqp://') >>> pool = connection.Pool(2) >>> c1 = pool.acquire() >>> c2 = pool.acquire() >>> c3 = pool.acquire() Traceback (most recent call last): File "", line 1, in File "kombu/connection.py", line 354, in acquire raise ConnectionLimitExceeded(self.limit) kombu.exceptions.ConnectionLimitExceeded: 2 >>> c1.release() >>> c3 = pool.acquire() (R(RGtlimittpreload((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytPoolYscC@st|||S(s?Pool of channels. See :class:`ChannelPool`. :keyword limit: Maximum number of active channels. Default is no limit. :keyword preload: Number of channels to preload when the pool is created. Default is 0. *Example usage*:: >>> connection = Connection('amqp://') >>> pool = connection.ChannelPool(2) >>> c1 = pool.acquire() >>> c2 = pool.acquire() >>> c3 = pool.acquire() Traceback (most recent call last): File "", line 1, in File "kombu/connection.py", line 354, in acquire raise ChannelLimitExceeded(self.limit) kombu.connection.ChannelLimitExceeded: 2 >>> c1.release() >>> c3 = pool.acquire() (R(RGRR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRuscO@s&ddlm}||p|||S(sJCreate new :class:`kombu.Producer` instance using this connection.i(tProducer(t messagingR(RGRgR^RIR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRscO@s)ddlm}||p||||S(sJCreate new :class:`kombu.Consumer` instance using this connection.i(tConsumer(RR(RGtqueuesRgR^RIR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRscK@s/ddlm}||p||||||S(spCreate new :class:`~kombu.simple.SimpleQueue`, using a channel from this connection. If ``name`` is a string, a queue and exchange will be automatically created using that name as the name of the queue and exchange, also it will be used as the default routing key. :param name: Name of the queue/or a :class:`~kombu.Queue`. :keyword no_ack: Disable acknowledgements. Default is false. :keyword queue_opts: Additional keyword arguments passed to the constructor of the automatically created :class:`~kombu.Queue`. :keyword exchange_opts: Additional keyword arguments passed to the constructor of the automatically created :class:`~kombu.Exchange`. :keyword channel: Custom channel to use. If not specified the connection default channel is used. i(t SimpleQueue(tsimpleR(RGtnametno_ackt queue_optst exchange_optsRgRIR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRscK@s/ddlm}||p||||||S(s|Create new :class:`~kombu.simple.SimpleQueue` using a channel from this connection. Same as :meth:`SimpleQueue`, but configured with buffering semantics. The resulting queue and exchange will not be durable, also auto delete is enabled. Messages will be transient (not persistent), and acknowledgements are disabled (``no_ack``). i(t SimpleBuffer(RR(RGRRRRRgRIR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRs cC@s0|jd|jj}|jd||S(Nsestablishing connection...sconnection established: %r(R`R*testablish_connection(RGtconn((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt_establish_connections cC@sdj|jt|S(s``x.__repr__() <==> repr(x)``s(R]RRY(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt__repr__scC@s |jS(s``x.__copy__() <==> copy(x)``(R(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt__copy__scC@s"|jt|jjdfS(N(RttupleRtvaluesR0(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt __reduce__scC@s|S(N((RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt __enter__scG@s|jdS(N(R(RGR^((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt__exit__scC@s|jj|jS(N(R*tqos_semantics_matches_specRW(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRscC@s,|j o+|jdk o+|jj|jS(s3Return true if the connection has been established.N(RORoR0R*tverify_connection(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt connecteds cC@sN|jsJ|jsC|jjd|_|j|_t|_n|jSdS(sThe underlying connection object. .. warning:: This instance is transport specific, so do not depend on the interface of this object. N( RORRFRMR0RnRRoRN(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRWs     cC@s/|j|jdkr(|j|_n|jS(sDDefault channel, created upon access and closed when the connection is closed. Can be used for automatic channel handling when you only need one channel, and also it is the channel implicitly used if a connection is passed instead of a channel, to functions that require a channel. N(RWRnR0Rg(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytdefault_channels cC@sdj|jt|jgS(s5The host as a host name/port pair separated by colon.t:(tjoinR#tstrR'(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pythostscC@s(|jdkr!|j|_n|jS(N(RvR0R(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyR* scC@s |jjS(swExperimental manager that can be used to manage/monitor the broker instance. Not available for all transports.(R*tmanager(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRscO@s|jj||S(N(R*t get_manager(RGR^RI((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRscC@s1y|jjSWntk r,|j|jSXdS(sList of connection related exceptions that can be recovered from, but where the connection must be closed and re-established first.N(R*RRqRkRl(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRs cC@s'y|jjSWntk r"dSXdS(s{List of channel related exceptions that can be automatically recovered from without re-establishing the connection.N((R*RRq(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyR)s cC@s |jjS(s8List of exceptions that may be raised by the connection.(R*Rk(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRk2scC@s |jjS(s5List of exceptions that may be raised by the channel.(R*Rl(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRl7scC@s |jjS(N(R*tsupports_heartbeats(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyR<scC@s |jjS(N(R*t supports_ev(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt is_evented@sN(URRRR0R'R&R+RORoRnRvRNRDR6RFRRAR?R=R-R#R$R%R)R,RKRRRSR:RVR`RaRgRiRjRmRtRxRRRLRRRRRRRR RRRCRRRRRRRRRRRRRRRRRtpropertyRRRWRRR*RRRRRRkRlRR(((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyR-s@    6            %     V '                  tResourcecB@seZejZdddZdZdZeddZ dZ dZ dZ dZ dZd Zd Zejjd re ZeZd Zd Z dZnRS(cC@sG||_|pd|_t|_t|_t|_|jdS(Ni( RRRNROt _LifoQueuet _resourceREt_dirtytsetup(RGRR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRKIs     cC@stddS(Nssubclass responsibility(tNotImplementedError(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRRscC@sP|jr6t|j|jkr6|j|jn|jj|jdS(N(RRRt LimitExceededRt put_nowaittnew(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt_add_when_emptyUs!c@sjrtdnjrxyjjd|d|Wntk r`jq$XyjWnCtk rt t rjj n j nXj jPq$Wnjjfd}|_ S(sKAcquire resource. :keyword block: If the limit is exceeded, block until there is an available item. :keyword timeout: Timeout to wait if ``block`` is true. Default is :const:`None` (forever). :raises LimitExceeded: if block is false and the limit has been exceeded. sAcquire on closed pooltblockR|c@sjdS(sRelease resource so it can be used by another thread. The caller is responsible for discarding the object, and to never use the resource again. A new resource must be acquired if so needed. N(R((tRRG(s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRs(ROt RuntimeErrorRRR>RRtpreparet BaseExceptionR2RRRRtaddR(RGRR|R((RRGs2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytacquire]s*      cC@s|S(N((RGtresource((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRscC@s|jdS(N(RL(RGR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytclose_resourcescC@sdS(N((RGR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytrelease_resourcescC@s-|jr|jj|n|j|dS(s_Replace resource with a new instance. This can be used in case of defective resources.N(RRtdiscardR(RGR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytreplaces cC@sJ|jr9|jj||jj||j|n |j|dS(N(RRRRRRR(RGR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRs  cC@sdS(N((RGR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytcollect_resourcescC@st|_|j}|j}xNy|j}Wntk rBPnXy|j|Wqtk rgqXqWxQy|jj}Wnt k rPnXy|j|Wqotk rqoXqoWdS(sClose and remove all resources in the pool (also those in use). Can be used to close resources from parent processes after fork (e.g. sockets/connections). N( RCRORRtpoptKeyErrorRRqtqueuet IndexError(RGtdirtyRtdrestres((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytforce_close_alls*       tKOMBU_DEBUG_POOLicO@sddl}|jd}|_dj||jjGH|j||}||_dj||jjGHt|dsg|_n|jj |j |S(Niis+{0} ACQUIRE {1}s-{0} ACQUIRE {1}t acquired_by( t tracebackt_next_resource_idR]RRt _orig_acquiret _resource_idRRtappendt format_stack(RGR^RIRRYtr((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRs   cC@sY|j}dj||jjGH|j|}dj||jjGH|jd8_|S(Ns+{0} RELEASE {1}s-{0} RELEASE {1}i(R R]RRt _orig_releaseR(RGRRYR ((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRs  N(RRRRR0RKRRRNRRRRRRRRtostenvironR>R RR(((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRFs$   1        cB@skeZejZd d dZdZdZdZ ddZ e e dZ dZdZRS( cC@s,||_tt|jd|d|dS(NRR(RWtsuperRRK(RGRWRR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRKs cC@s |jjS(N(RWR(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRscC@s)y|jdWntk r$nXdS(Ntreleased(R`Rq(RGR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRs cC@s|jdS(N(Rx(RGR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRsg?cC@s |j|S(N(R(RGRR}((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRscc@s-|jd|}||jfVWdQXdS(NR(RR(RGRRW((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytacquire_channelscC@sq|jrmxat|jD]M}||jkrG|j}|jnt|j}|jj|qWndS(N(RRRRRaRRR(RGtiR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRs   cC@s)t|r|}n|jd|S(Ntacquired(tcallableR`(RGR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyR s   N(RRRtConnectionLimitExceededRR0RKRRRRRRNRRR(((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRs      cB@s;eZejZdddZdZdZdZ RS(cC@s,||_tt|jd|d|dS(NRR(RWRRRK(RGRWRR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRKs cC@st|jjS(N(RRWRg(RG((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRscC@sd|j}|jr`xHt|jD]4}|jj||jkrL|pUt|q%WndS(N(RRRRRRR(RGRgR((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRs    cC@st|r|}n|S(N(R(RGRg((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyR#s  N( RRRtChannelLimitExceededRR0RKRRR(((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyRs    cC@st|tr|jS|S(smReturn the default channel if argument is a connection instance, otherwise just return the channel given.(R2RR(Rg((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt maybe_channel)scC@s t|tS(N(R2R(R((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pyt is_connection1s(;Rt __future__RRRrt contextlibRt itertoolsRRtoperatorRtkombuRtfiveRRRR R RtlogR R*R R tutilsRRRRt utils.compatRtutils.functionalRt utils.urlRRRRt__all__RRR>RNRBRdRR[troundrobin_failoverR=RRtBrokerConnectionRRRRR(((s2/tmp/pip-unpacked-wheel-UAnTfW/kombu/connection.pytsD  (""    -