Initial commit

backend/venv/Lib/site-packages/pika-1.3.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

backend/venv/Lib/site-packages/pika-1.3.2.dist-info/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2009-2021, Tony Garnock-Jones, Gavin M. Roy, Pivotal Software, Inc and others.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * Neither the name of the Pika project nor the names of its contributors may be used
+   to endorse or promote products derived from this software without specific
+   prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

backend/venv/Lib/site-packages/pika-1.3.2.dist-info/METADATA

@@ -0,0 +1,320 @@
+Metadata-Version: 2.1
+Name: pika
+Version: 1.3.2
+Summary: Pika Python AMQP Client Library
+Maintainer-email: "Gavin M. Roy" <gavinmroy@gmail.com>, Luke Bakken <lukerbakken@gmail.com>
+License: BSD-3-Clause
+Project-URL: Homepage, https://pika.readthedocs.io
+Project-URL: Source, https://github.com/pika/pika
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: Jython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Communications
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Provides-Extra: gevent
+Requires-Dist: gevent ; extra == 'gevent'
+Provides-Extra: tornado
+Requires-Dist: tornado ; extra == 'tornado'
+Provides-Extra: twisted
+Requires-Dist: twisted ; extra == 'twisted'
+
+Pika
+====
+Pika is a RabbitMQ (AMQP 0-9-1) client library for Python.
+
+|Version| |Python versions| |Actions Status| |Coverage| |License| |Docs|
+
+Introduction
+------------
+Pika is a pure-Python implementation of the AMQP 0-9-1 protocol including
+RabbitMQ's extensions.
+
+- Supports Python 3.7+ (`1.1.0` was the last version to support 2.7)
+- Since threads aren't appropriate to every situation, it doesn't require
+  threads. Pika core takes care not to forbid them, either. The same goes for
+  greenlets, callbacks, continuations, and generators. An instance of Pika's
+  built-in connection adapters isn't thread-safe, however.
+- People may be using direct sockets, plain old ``select()``, or any of the
+  wide variety of ways of getting network events to and from a Python
+  application. Pika tries to stay compatible with all of these, and to make
+  adapting it to a new environment as simple as possible.
+
+Documentation
+-------------
+Pika's documentation can be found at https://pika.readthedocs.io.
+
+Example
+-------
+Here is the most simple example of use, sending a message with the
+``pika.BlockingConnection`` adapter:
+
+.. code :: python
+
+    import pika
+
+    connection = pika.BlockingConnection()
+    channel = connection.channel()
+    channel.basic_publish(exchange='test', routing_key='test',
+                          body=b'Test message.')
+    connection.close()
+
+And an example of writing a blocking consumer:
+
+.. code :: python
+
+    import pika
+
+    connection = pika.BlockingConnection()
+    channel = connection.channel()
+
+    for method_frame, properties, body in channel.consume('test'):
+        # Display the message parts and acknowledge the message
+        print(method_frame, properties, body)
+        channel.basic_ack(method_frame.delivery_tag)
+
+        # Escape out of the loop after 10 messages
+        if method_frame.delivery_tag == 10:
+            break
+
+    # Cancel the consumer and return any pending messages
+    requeued_messages = channel.cancel()
+    print('Requeued %i messages' % requeued_messages)
+    connection.close()
+
+Pika provides the following adapters
+------------------------------------
+
+- ``pika.adapters.asyncio_connection.AsyncioConnection`` - asynchronous adapter
+  for Python 3 `AsyncIO <https://docs.python.org/3/library/asyncio.html>`_'s
+  I/O loop.
+- ``pika.BlockingConnection`` - synchronous adapter on top of library for
+  simple usage.
+- ``pika.SelectConnection`` - asynchronous adapter without third-party
+  dependencies.
+- ``pika.adapters.gevent_connection.GeventConnection`` - asynchronous adapter
+  for use with `Gevent <http://www.gevent.org>`_'s I/O loop.
+- ``pika.adapters.tornado_connection.TornadoConnection`` - asynchronous adapter
+  for use with `Tornado <http://tornadoweb.org>`_'s I/O loop.
+- ``pika.adapters.twisted_connection.TwistedProtocolConnection`` - asynchronous
+  adapter for use with `Twisted <http://twistedmatrix.com>`_'s I/O loop.
+
+Multiple connection parameters
+------------------------------
+You can also pass multiple ``pika.ConnectionParameters`` instances for
+fault-tolerance as in the code snippet below (host names are just examples, of
+course). To enable retries, set ``connection_attempts`` and ``retry_delay`` as
+needed in the last ``pika.ConnectionParameters`` element of the sequence.
+Retries occur after connection attempts using all of the given connection
+parameters fail.
+
+.. code :: python
+
+    import pika
+
+    parameters = (
+        pika.ConnectionParameters(host='rabbitmq.zone1.yourdomain.com'),
+        pika.ConnectionParameters(host='rabbitmq.zone2.yourdomain.com',
+                                  connection_attempts=5, retry_delay=1))
+    connection = pika.BlockingConnection(parameters)
+
+With non-blocking adapters, such as ``pika.SelectConnection`` and
+``pika.adapters.asyncio_connection.AsyncioConnection``, you can request a
+connection using multiple connection parameter instances via the connection
+adapter's ``create_connection()`` class method.
+
+Requesting message acknowledgements from another thread
+-------------------------------------------------------
+The single-threaded usage constraint of an individual Pika connection adapter
+instance may result in a dropped AMQP/stream connection due to AMQP heartbeat
+timeout in consumers that take a long time to process an incoming message. A
+common solution is to delegate processing of the incoming messages to another
+thread, while the connection adapter's thread continues to service its I/O
+loop's message pump, permitting AMQP heartbeats and other I/O to be serviced in
+a timely fashion.
+
+Messages processed in another thread may not be acknowledged directly from that
+thread, since all accesses to the connection adapter instance must be from a
+single thread, which is the thread running the adapter's I/O loop. This is
+accomplished by requesting a callback to be executed in the adapter's
+I/O loop thread. For example, the callback function's implementation might look
+like this:
+
+.. code :: python
+
+    def ack_message(channel, delivery_tag):
+        """Note that `channel` must be the same Pika channel instance via which
+        the message being acknowledged was retrieved (AMQP protocol constraint).
+        """
+        if channel.is_open:
+            channel.basic_ack(delivery_tag)
+        else:
+            # Channel is already closed, so we can't acknowledge this message;
+            # log and/or do something that makes sense for your app in this case.
+            pass
+
+The code running in the other thread may request the ``ack_message()`` function
+to be executed in the connection adapter's I/O loop thread using an
+adapter-specific mechanism:
+
+- ``pika.BlockingConnection`` abstracts its I/O loop from the application and
+  thus exposes ``pika.BlockingConnection.add_callback_threadsafe()``. Refer to
+  this method's docstring for additional information. For example:
+
+  .. code :: python
+
+      connection.add_callback_threadsafe(functools.partial(ack_message, channel, delivery_tag))
+
+- When using a non-blocking connection adapter, such as
+  ``pika.adapters.asyncio_connection.AsyncioConnection`` or
+  ``pika.SelectConnection``, you use the underlying asynchronous framework's
+  native API for requesting an I/O loop-bound callback from another thread. For
+  example, ``pika.SelectConnection``'s I/O loop provides
+  ``add_callback_threadsafe()``,
+  ``pika.adapters.tornado_connection.TornadoConnection``'s I/O loop has
+  ``add_callback()``, while
+  ``pika.adapters.asyncio_connection.AsyncioConnection``'s I/O loop exposes
+  ``call_soon_threadsafe()``.
+
+This threadsafe callback request mechanism may also be used to delegate
+publishing of messages, etc., from a background thread to the connection
+adapter's thread.
+
+Connection recovery
+-------------------
+
+Some RabbitMQ clients (Bunny, Java, .NET, Objective-C, Swift) provide a way to
+automatically recover a connection, its channels and topology (e.g. queues,
+bindings and consumers) after a network failure. Others require connection
+recovery to be performed by the application code and strive to make it a
+straightforward process. Pika falls into the second category.
+
+Pika supports multiple connection adapters. They take different approaches to
+connection recovery.
+
+For ``pika.BlockingConnection`` adapter exception handling can be used to check
+for connection errors. Here is a very basic example:
+
+.. code :: python
+
+    import pika
+
+    while True:
+        try:
+            connection = pika.BlockingConnection()
+            channel = connection.channel()
+            channel.basic_consume('test', on_message_callback)
+            channel.start_consuming()
+        # Don't recover if connection was closed by broker
+        except pika.exceptions.ConnectionClosedByBroker:
+            break
+        # Don't recover on channel errors
+        except pika.exceptions.AMQPChannelError:
+            break
+        # Recover on all other connection errors
+        except pika.exceptions.AMQPConnectionError:
+            continue
+
+This example can be found in `examples/consume_recover.py`.
+
+Generic operation retry libraries such as
+`retry <https://github.com/invl/retry>`_ can be used. Decorators make it
+possible to configure some additional recovery behaviours, like delays between
+retries and limiting the number of retries:
+
+.. code :: python
+
+    from retry import retry
+
+
+    @retry(pika.exceptions.AMQPConnectionError, delay=5, jitter=(1, 3))
+    def consume():
+        connection = pika.BlockingConnection()
+        channel = connection.channel()
+        channel.basic_consume('test', on_message_callback)
+
+        try:
+            channel.start_consuming()
+        # Don't recover connections closed by server
+        except pika.exceptions.ConnectionClosedByBroker:
+            pass
+
+
+    consume()
+
+This example can be found in `examples/consume_recover_retry.py`.
+
+For asynchronous adapters, use ``on_close_callback`` to react to connection
+failure events. This callback can be used to clean up and recover the
+connection.
+
+An example of recovery using ``on_close_callback`` can be found in
+`examples/asynchronous_consumer_example.py`.
+
+Contributing
+------------
+To contribute to Pika, please make sure that any new features or changes to
+existing functionality **include test coverage**.
+
+*Pull requests that add or change code without adequate test coverage will be
+rejected.*
+
+Additionally, please format your code using
+`Yapf <http://pypi.python.org/pypi/yapf>`_ with ``google`` style prior to
+issuing your pull request. *Note: only format those lines that you have changed
+in your pull request. If you format an entire file and change code outside of
+the scope of your PR, it will likely be rejected.*
+
+Extending to support additional I/O frameworks
+----------------------------------------------
+New non-blocking adapters may be implemented in either of the following ways:
+
+- By subclassing ``pika.BaseConnection``, implementing its abstract method and
+  passing its constructor an implementation of
+  ``pika.adapters.utils.nbio_interface.AbstractIOServices``.
+  ``pika.BaseConnection`` implements ``pika.connection.Connection``'s abstract
+  methods, including internally-initiated connection logic. For examples, refer
+  to the implementations of
+  ``pika.adapters.asyncio_connection.AsyncioConnection``,
+  ``pika.adapters.gevent_connection.GeventConnection`` and
+  ``pika.adapters.tornado_connection.TornadoConnection``.
+- By subclassing ``pika.connection.Connection`` and implementing its abstract
+  methods. This approach facilitates implementation of custom
+  connection-establishment and transport mechanisms. For an example, refer to
+  the implementation of
+  ``pika.adapters.twisted_connection.TwistedProtocolConnection``.
+
+.. |Version| image:: https://img.shields.io/pypi/v/pika.svg?
+   :target: http://badge.fury.io/py/pika
+
+.. |Python versions| image:: https://img.shields.io/pypi/pyversions/pika.svg
+    :target: https://pypi.python.org/pypi/pika
+
+.. |Actions Status| image:: https://github.com/pika/pika/actions/workflows/main.yaml/badge.svg
+   :target: https://github.com/pika/pika/actions/workflows/main.yaml
+
+.. |Coverage| image:: https://img.shields.io/codecov/c/github/pika/pika.svg?
+   :target: https://codecov.io/github/pika/pika?branch=main
+
+.. |License| image:: https://img.shields.io/pypi/l/pika.svg?
+   :target: https://pika.readthedocs.io
+
+.. |Docs| image:: https://readthedocs.org/projects/pika/badge/?version=stable
+   :target: https://pika.readthedocs.io
+   :alt: Documentation Status

backend/venv/Lib/site-packages/pika-1.3.2.dist-info/RECORD

@@ -0,0 +1,68 @@
+pika-1.3.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pika-1.3.2.dist-info/LICENSE,sha256=21HeRCNF3Ho285qYfFcVgx8Kfy0lg65jKQFNDDIvYrk,1552
+pika-1.3.2.dist-info/METADATA,sha256=VHmz3pPAkWR45GIHPzGR3dswemh0G--XHdeB_xsqXZ4,13052
+pika-1.3.2.dist-info/RECORD,,
+pika-1.3.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pika-1.3.2.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+pika-1.3.2.dist-info/top_level.txt,sha256=ATSgSqw16wMD-Dht8AJlcJobg1xKjOwpbPEvKZJqfzg,5
+pika-1.3.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pika/__init__.py,sha256=fGTPYlzKxqsnr6aYkMTkp1GVLl71BXcXtCY7QLSyTvI,693
+pika/__pycache__/__init__.cpython-310.pyc,,
+pika/__pycache__/amqp_object.cpython-310.pyc,,
+pika/__pycache__/callback.cpython-310.pyc,,
+pika/__pycache__/channel.cpython-310.pyc,,
+pika/__pycache__/compat.cpython-310.pyc,,
+pika/__pycache__/connection.cpython-310.pyc,,
+pika/__pycache__/credentials.cpython-310.pyc,,
+pika/__pycache__/data.cpython-310.pyc,,
+pika/__pycache__/delivery_mode.cpython-310.pyc,,
+pika/__pycache__/diagnostic_utils.cpython-310.pyc,,
+pika/__pycache__/exceptions.cpython-310.pyc,,
+pika/__pycache__/exchange_type.cpython-310.pyc,,
+pika/__pycache__/frame.cpython-310.pyc,,
+pika/__pycache__/heartbeat.cpython-310.pyc,,
+pika/__pycache__/spec.cpython-310.pyc,,
+pika/__pycache__/tcp_socket_opts.cpython-310.pyc,,
+pika/__pycache__/validators.cpython-310.pyc,,
+pika/adapters/__init__.py,sha256=GTUPWmxBgTEuZp0zrOqX9GX5gIwZfv3nTWi1uXwdBUU,994
+pika/adapters/__pycache__/__init__.cpython-310.pyc,,
+pika/adapters/__pycache__/asyncio_connection.cpython-310.pyc,,
+pika/adapters/__pycache__/base_connection.cpython-310.pyc,,
+pika/adapters/__pycache__/blocking_connection.cpython-310.pyc,,
+pika/adapters/__pycache__/gevent_connection.cpython-310.pyc,,
+pika/adapters/__pycache__/select_connection.cpython-310.pyc,,
+pika/adapters/__pycache__/tornado_connection.cpython-310.pyc,,
+pika/adapters/__pycache__/twisted_connection.cpython-310.pyc,,
+pika/adapters/asyncio_connection.py,sha256=z9SmKmFCft_PPq-mD_AS_PsOijMHwH2mAnMVsTEmkVY,9235
+pika/adapters/base_connection.py,sha256=5QpA2q1qlV8sHSMHITVb6hDCbn3ErXQOc23MQi66oOQ,20525
+pika/adapters/blocking_connection.py,sha256=gtXhod6U649z5WvnpWfdUoi9qZtkbknT1DioYt6Gkmw,110248
+pika/adapters/gevent_connection.py,sha256=RM-Ol6PcFyrkBqFx7tOVOhXQGZKqHGgOSuLPO7fgqdA,16735
+pika/adapters/select_connection.py,sha256=Jp4JfqhptZ955apFhymJzM2oK7P8O9D7hKf0fTZ9xC0,45162
+pika/adapters/tornado_connection.py,sha256=q5QwUBkC_pSq8kr9R3TorInpXINM9sbFHYJsj2-4rjM,3559
+pika/adapters/twisted_connection.py,sha256=hACt_5Lxs5F0nsbe5qG-h9lrKEPfL_VGnjUhonet4Is,50294
+pika/adapters/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pika/adapters/utils/__pycache__/__init__.cpython-310.pyc,,
+pika/adapters/utils/__pycache__/connection_workflow.cpython-310.pyc,,
+pika/adapters/utils/__pycache__/io_services_utils.cpython-310.pyc,,
+pika/adapters/utils/__pycache__/nbio_interface.cpython-310.pyc,,
+pika/adapters/utils/__pycache__/selector_ioloop_adapter.cpython-310.pyc,,
+pika/adapters/utils/connection_workflow.py,sha256=8qDbckjKXHv9WmymheKr6pm1_KQm9cKSf11ipSW_ydE,33845
+pika/adapters/utils/io_services_utils.py,sha256=fCYJFW7t3cN3aYW9GuUBnMHf0Aq-UlytnOulufer2sg,53574
+pika/adapters/utils/nbio_interface.py,sha256=fiz6CMh5FvrV0_cjO1DsrpA4YINRYhWIdVp67SZLh3g,17217
+pika/adapters/utils/selector_ioloop_adapter.py,sha256=F55JelsVb3agQ7z-1V8I3fo1JxTxhXy-0J53KshqYVI,19955
+pika/amqp_object.py,sha256=-7u2LCPy-DQODB30Jt7WfxsINuMXmSu5BjqITCzWMbk,1830
+pika/callback.py,sha256=l_9kQBW5Ta4f1tPuVUaddjfFqwu1uPyoBPDXSP4-KLw,14743
+pika/channel.py,sha256=ynFkBA7JY5Axvi5uCGhhKmfU4IjbngO0SRhoBF6NMAw,63112
+pika/compat.py,sha256=f_zeLXYgzwj8zFh6ZjUa7b-vEpm7c7hK_4bMYrfH28E,7221
+pika/connection.py,sha256=14L1q-u1Jc1t_HG062E5TWRSdHgTui_tmrOAzcoFhGw,87627
+pika/credentials.py,sha256=1EIMKuFrWLqCWitRFiqLRCx25HTYid-tnQGH-4gJ4Yg,4646
+pika/data.py,sha256=SxYCuololigT9w3tLvZY3AJtBcSb0UJoxXoQlvZ7Ong,9956
+pika/delivery_mode.py,sha256=nMjT1H7REUFhxPtvqsovQy03AemnhKLcmlq3UQ0NeSI,87
+pika/diagnostic_utils.py,sha256=nxYnlMJejjoDtfUx_3QBgy1y-jwy1bghEYfejphakuY,1759
+pika/exceptions.py,sha256=CjT1lYgvUe79zGOAmvTGsylTUKGz_YCdnzL7FDYyhqw,10117
+pika/exchange_type.py,sha256=afA-c21QmVNuuUHKoHYYvrIg6oUOXThd4lpPsDz1ilE,390
+pika/frame.py,sha256=0IhYLWvEeRvHhB4K-z3jF6Dv_FoxskzNuAXhq9LFpuo,7744
+pika/heartbeat.py,sha256=hoORwZHRZsi3Im6o7y05H86dTiO9-XAK4s28wsjjiK8,8170
+pika/spec.py,sha256=2pQLO4hFOu0QNRA1ry6kGpqJ6yQRAZviMoOrmrb4CYQ,80448
+pika/tcp_socket_opts.py,sha256=QPU762BQKqY94RohuG57fz0EZ5CyabezcJxySouckAs,1513
+pika/validators.py,sha256=iLw8dwbnNaEK3yd_TU-BplIpQ4jx4SMYSmTR-HikNc0,1419

backend/venv/Lib/site-packages/pika-1.3.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.40.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

backend/venv/Lib/site-packages/pika-1.3.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+pika

backend/venv/Lib/site-packages/pika-1.3.2.dist-info/zip-safe

@@ -0,0 +1 @@
+