in}9d2>&kvfG(N62j9K|$ur=o}~WeGu7D7e0B95z*J!0pDk1w#Ghl_YL*O{2g}p
zj3IZasT|BQdVa=KGHlMqBZR28!S>=H94^jvocdWbn^@tq3eA5XQDe*xEoF`QU#z
zkvfCtM{GiRAthd=59lpv{k|nQEMbx6g}qH$a7OP|d>p@s<75|}6vMwjPCx0)xm{}y
z{$Hm*RKU@@2}swee3-j>zS)l0aj)u
zql=oISqVI1GF4`8%CyF_(r!0ucaIB>QM81p5q=V+>UdoJ2sbChJVL#c9Wc&PZdwb(
z<3zmFDf%GdK7=2eRH2{y6;!cRI^cfmp%$mAAO%qNG8xPo{lnPq+FTT+P-#~7+sR<>C;{Mo2nrp<
zY=l(^r2O2n^@^EhT}r>3rUU)6Mq@KdyTcZ=)ble@=nMZ;XR3iXI+ZCMs);L%xQaF$$O=S1$2R@GT~s$nf@W
z{A<4Nq}G^?QPKbbJFxdlD8WW?$u3{uO(V{fTuDEnxsp*k7_OYs-cqIPRzvbH)fUhZI4P
ztw`G^Oh7Z!p?x${Qkgk1>pc&>9KcDq$9P^zP%p7q%8te$5nLjK7hDpj(^lHa+N`
z08mabTKbaRhiHdXzFN)EQ!}ru&jL-2tLHJkW~uYIz*?~LH(dP~o!kz_1j}tDQO{07
z+;3?CTCKuI9~6jYPEh|I64Z~(d_tZnrxoP{_0uV;DO@*?xyKo^C_jh0-W)E5fLH8S-r7RIi{JUHne<5Wcw*F%O}Lp3mS#Fx{~QVyGZe
z&>BXuFja@Tj;Z0NQ&~(0l<_}cjFMn$7^L>=|$fE2SD)tfSK0?8B7Z3r>Ry1_v
znW%>yPZKqFxf5*0Ned-<=E=U$yQo_*a1{fyQb$n^a^k3eqDU)W+LYLQ4b)|WfijTw
zg~ME{`l#|~bmehM{#KLDFEv%Go_
z&w4l~28V}Q-ow$k?}fz#)S9O*(fsdFLpwS31~o)F^-DC_5@4iJdy<@K-8n2XPk0G0
zZs0U!tB2g+d0y43RJo!zM~H_0Y@+d($uHAerEFaU4ahim+$`$obfT0+7l?D;iQ8|YLFr2fGO)2GIJF$0~gI=6{
zVxH{g>8Mu9_jfn(Vdmzgzq&=8%12>5l-KB&$76w=#h@>6npAD^RlWqDwH_&YUR%v)
zrIKFJo;**;w13Q=Bp*tn{xsoG2GXibud3KaYuC~&H}V4u4BSO25D|hW&>{f_(MC~TK*Ix83+v16ad$qgmjh~EK?fxdqPdn|q>3+6
zq$neKtg&Q|hx+}V5{w=foJfDR;x9TPKBRakgvzP2zUrIO%IUQlcbb85p5s3HoK0%C
zyOqp(#`vP55RGYG9T}=I1n=;!!i!w_p|1o|DiAWuRKl8)c(4H>$t~}uB_3nOz!+o`
wYAkEW{RXO2OsQPX7IR=9aaxI={X~X;KftfytU5K_w}RY0$9LVPXyXjkH+)b>>Hq)$
literal 0
HcmV?d00001
diff --git a/server/venv/lib/python3.10/site-packages/_distutils_hack/override.py b/server/venv/lib/python3.10/site-packages/_distutils_hack/override.py
new file mode 100644
index 0000000..2cc433a
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/_distutils_hack/override.py
@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()
diff --git a/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/INSTALLER b/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/INSTALLER
new file mode 100644
index 0000000..a1b589e
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/LICENSE.rst b/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/LICENSE.rst
new file mode 100644
index 0000000..79c9825
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/LICENSE.rst
@@ -0,0 +1,20 @@
+Copyright 2010 Jason Kirtland
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/METADATA b/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/METADATA
new file mode 100644
index 0000000..f96613c
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/METADATA
@@ -0,0 +1,62 @@
+Metadata-Version: 2.1
+Name: blinker
+Version: 1.7.0
+Summary: Fast, simple object-to-object and broadcast signaling
+Keywords: signal,emit,events,broadcast
+Author-email: Jason Kirtland
+Maintainer-email: Pallets Ecosystem
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries
+Project-URL: Chat, https://discord.gg/pallets
+Project-URL: Documentation, https://blinker.readthedocs.io
+Project-URL: Homepage, https://blinker.readthedocs.io
+Project-URL: Issue Tracker, https://github.com/pallets-eco/blinker/issues/
+Project-URL: Source Code, https://github.com/pallets-eco/blinker/
+
+Blinker
+=======
+
+Blinker provides a fast dispatching system that allows any number of
+interested parties to subscribe to events, or "signals".
+
+Signal receivers can subscribe to specific senders or receive signals
+sent by any sender.
+
+.. code-block:: pycon
+
+ >>> from blinker import signal
+ >>> started = signal('round-started')
+ >>> def each(round):
+ ... print(f"Round {round}")
+ ...
+ >>> started.connect(each)
+
+ >>> def round_two(round):
+ ... print("This is round two.")
+ ...
+ >>> started.connect(round_two, sender=2)
+
+ >>> for round in range(1, 4):
+ ... started.send(round)
+ ...
+ Round 1!
+ Round 2!
+ This is round two.
+ Round 3!
+
+
+Links
+-----
+
+- Documentation: https://blinker.readthedocs.io/
+- Changes: https://blinker.readthedocs.io/#changes
+- PyPI Releases: https://pypi.org/project/blinker/
+- Source Code: https://github.com/pallets-eco/blinker/
+- Issue Tracker: https://github.com/pallets-eco/blinker/issues/
+
diff --git a/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/RECORD b/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/RECORD
new file mode 100644
index 0000000..51a7d03
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/RECORD
@@ -0,0 +1,14 @@
+blinker-1.7.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+blinker-1.7.0.dist-info/LICENSE.rst,sha256=nrc6HzhZekqhcCXSrhvjg5Ykx5XphdTw6Xac4p-spGc,1054
+blinker-1.7.0.dist-info/METADATA,sha256=kDgzPgrw4he78pEX88bSAqwYMVWrfUMk8QmNjekjg_U,1918
+blinker-1.7.0.dist-info/RECORD,,
+blinker-1.7.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+blinker/__init__.py,sha256=s75XaRDHwSDzZ21BZUOEkQDQIcQEyT8hT7vk3EhYFQU,408
+blinker/__pycache__/__init__.cpython-310.pyc,,
+blinker/__pycache__/_saferef.cpython-310.pyc,,
+blinker/__pycache__/_utilities.cpython-310.pyc,,
+blinker/__pycache__/base.cpython-310.pyc,,
+blinker/_saferef.py,sha256=kWOTIWnCY3kOb8lZP74Rbx7bR_BLVg4TjwzNCRLhKHs,9096
+blinker/_utilities.py,sha256=S2njKDmlBpK_yCK4RT8hq98hEj30I0TQCC5mNhtY22I,2856
+blinker/base.py,sha256=FqZmAI5YzuRrvRmye1Jb-utyVOjXtF5vUVP3-1u-HtU,20544
+blinker/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
diff --git a/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/WHEEL b/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/WHEEL
new file mode 100644
index 0000000..3b5e64b
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/blinker-1.7.0.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/server/venv/lib/python3.10/site-packages/blinker/__init__.py b/server/venv/lib/python3.10/site-packages/blinker/__init__.py
new file mode 100644
index 0000000..d014caa
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/blinker/__init__.py
@@ -0,0 +1,19 @@
+from blinker.base import ANY
+from blinker.base import NamedSignal
+from blinker.base import Namespace
+from blinker.base import receiver_connected
+from blinker.base import Signal
+from blinker.base import signal
+from blinker.base import WeakNamespace
+
+__all__ = [
+ "ANY",
+ "NamedSignal",
+ "Namespace",
+ "Signal",
+ "WeakNamespace",
+ "receiver_connected",
+ "signal",
+]
+
+__version__ = "1.7.0"
diff --git a/server/venv/lib/python3.10/site-packages/blinker/__pycache__/__init__.cpython-310.pyc b/server/venv/lib/python3.10/site-packages/blinker/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ff4b30fd4ed75fcb874c0244be9eb0525ce1c0a0
GIT binary patch
literal 510
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
literal 0
HcmV?d00001
diff --git a/server/venv/lib/python3.10/site-packages/blinker/__pycache__/_utilities.cpython-310.pyc b/server/venv/lib/python3.10/site-packages/blinker/__pycache__/_utilities.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5908a74f9d29d9ef653d52d670394b0a16fe0292
GIT binary patch
literal 3536
zcmaJ@Pj4H?72lcN~i~uKfVL*~b7q_N(+V*Pi+ndP#q8mZT^v=q`3==FOX#_ul;8pKNut=HU6q
zzy2=wR~+ZxG+2H-3_6a(@_(Wu9KjN2z`Bf4pC`QQqIDB*;CFpX^ODk_+$}Rlx~CO<
zRauj@KHqiZ3R-v9>DC`P!WX40N0cskcU6?-YPbekMU+7+gSIZ-5vyYD%Ih|yFUx)2
zy@UC6(ZDjZDXIif(&;kcbh%)HUpcUV
zD?GGbp;gxxWt>_ul-Pg?w`VAq3QF)YCx}
zr1Bz2qk$Abv0Lk~$xS5;i57;&qZSk|mq}lhvEg@)s-pStH|>*bAls)=o~7+)Szlj7
zO1Aq+l%IW&%D?K-(nrswS>K5h@kutEB9>!T0bd939J!>D%_y_9+TIEm9U
zaE2otC$WxY-WrZcia3pR7}jxKPMS6Nq%qUFHJ|J;Ow1qZ6Qfn1mT4${%KEI2oBEEC
zZlyxcLKmhgV6qAoKLV?%g`tvS)Pn)Yg!bq#
z;#3YK&dd6NK9Rxa2ag^X^kpJ76m1pad?AN2(r~0+lqC7mPJ47c
zQ1&8D60A+IqaLZ$3Yudoh^?`Da<PGI7!j(3~!?cB8^rUg)R2vt88L?s)Tub(`QRxnLJ&BIt_wh_|ff;<%v5uk3fnzINTGmt4I;IJp;-^Zr9=yp{t%A#z}dlPaa422EOn-cdc(VDe+r3D
z$S@sr2n&}?)##4lMf{bU`kK%CQ~uh0G_n2k;D
ze^I!1lm;_75fjK}6sKBE-&80-kWtOXyoUtPmr4Q#Rz~9^Jq~hstVBHlM3fXcMX~Z2
zSyOQudbF!?&*a$n=TS0}OQx`psV=sC1pb^75#l|o@rH$p`WS>8_MmMSp7SRR7M|09
z-=H2DG1VySA>6+qr`mZBo)KUkK*D@*W8N!lM+sum`G1yqe-0zW)!>*)rfVDxZ1I%0
z6k*pUaUH3bQk!a)hC(6?OZ8Js0Wm*8W7!nxVX4-nO>Rx7+C;rZ44Fy2kKYkK8`ZV|
zlr6-y8ng6Uenckf5L^Ou=6+Ook>mW3`JnI~
zq?s&D#(|_OvXMU?ixl;ct3JUh)uJDHVbd#0F&p`|iAvG!t(&4Of@?=A!JNIV3L;*OHSnL@eOqkH
zc{>$ZvlO+`Z*LxPorZpci5GN6Q6|~&;VGg*PAek$qxup3s4^;a;st@COmmy+wEhT*
z9(7vbt|dJl0^EjaQ=Y|8MK(2!S^e7z^N7Mg-(uJJU#19`#y=Vj6RF;#V}4FQdmu%v
zB0N&vW<$QIK1V#DY?xcfTlcmgwvsQ|a-pcHd|K3!52$d>DLK_03YB$!kFU9<`kGtY
QsjM_yUa5ayTivMs4?`ju>Hq)$
literal 0
HcmV?d00001
diff --git a/server/venv/lib/python3.10/site-packages/blinker/__pycache__/base.cpython-310.pyc b/server/venv/lib/python3.10/site-packages/blinker/__pycache__/base.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e234801bf65afe7ae99282df50dd8031ef59bf46
GIT binary patch
literal 17510
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
z 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
+# OWNER 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.
+#
+"""Refactored 'safe reference from dispatcher.py"""
+import operator
+import sys
+import traceback
+import weakref
+
+
+get_self = operator.attrgetter("__self__")
+get_func = operator.attrgetter("__func__")
+
+
+def safe_ref(target, on_delete=None):
+ """Return a *safe* weak reference to a callable target.
+
+ - ``target``: The object to be weakly referenced, if it's a bound
+ method reference, will create a BoundMethodWeakref, otherwise
+ creates a simple weakref.
+
+ - ``on_delete``: If provided, will have a hard reference stored to
+ the callable to be called after the safe reference goes out of
+ scope with the reference object, (either a weakref or a
+ BoundMethodWeakref) as argument.
+ """
+ try:
+ im_self = get_self(target)
+ except AttributeError:
+ if callable(on_delete):
+ return weakref.ref(target, on_delete)
+ else:
+ return weakref.ref(target)
+ else:
+ if im_self is not None:
+ # Turn a bound method into a BoundMethodWeakref instance.
+ # Keep track of these instances for lookup by disconnect().
+ assert hasattr(target, "im_func") or hasattr(target, "__func__"), (
+ f"safe_ref target {target!r} has im_self, but no im_func, "
+ "don't know how to create reference"
+ )
+ reference = BoundMethodWeakref(target=target, on_delete=on_delete)
+ return reference
+
+
+class BoundMethodWeakref:
+ """'Safe' and reusable weak references to instance methods.
+
+ BoundMethodWeakref objects provide a mechanism for referencing a
+ bound method without requiring that the method object itself
+ (which is normally a transient object) is kept alive. Instead,
+ the BoundMethodWeakref object keeps weak references to both the
+ object and the function which together define the instance method.
+
+ Attributes:
+
+ - ``key``: The identity key for the reference, calculated by the
+ class's calculate_key method applied to the target instance method.
+
+ - ``deletion_methods``: Sequence of callable objects taking single
+ argument, a reference to this object which will be called when
+ *either* the target object or target function is garbage
+ collected (i.e. when this object becomes invalid). These are
+ specified as the on_delete parameters of safe_ref calls.
+
+ - ``weak_self``: Weak reference to the target object.
+
+ - ``weak_func``: Weak reference to the target function.
+
+ Class Attributes:
+
+ - ``_all_instances``: Class attribute pointing to all live
+ BoundMethodWeakref objects indexed by the class's
+ calculate_key(target) method applied to the target objects.
+ This weak value dictionary is used to short-circuit creation so
+ that multiple references to the same (object, function) pair
+ produce the same BoundMethodWeakref instance.
+ """
+
+ _all_instances = weakref.WeakValueDictionary() # type: ignore[var-annotated]
+
+ def __new__(cls, target, on_delete=None, *arguments, **named):
+ """Create new instance or return current instance.
+
+ Basically this method of construction allows us to
+ short-circuit creation of references to already-referenced
+ instance methods. The key corresponding to the target is
+ calculated, and if there is already an existing reference,
+ that is returned, with its deletion_methods attribute updated.
+ Otherwise the new instance is created and registered in the
+ table of already-referenced methods.
+ """
+ key = cls.calculate_key(target)
+ current = cls._all_instances.get(key)
+ if current is not None:
+ current.deletion_methods.append(on_delete)
+ return current
+ else:
+ base = super().__new__(cls)
+ cls._all_instances[key] = base
+ base.__init__(target, on_delete, *arguments, **named)
+ return base
+
+ def __init__(self, target, on_delete=None):
+ """Return a weak-reference-like instance for a bound method.
+
+ - ``target``: The instance-method target for the weak reference,
+ must have im_self and im_func attributes and be
+ reconstructable via the following, which is true of built-in
+ instance methods::
+
+ target.im_func.__get__( target.im_self )
+
+ - ``on_delete``: Optional callback which will be called when
+ this weak reference ceases to be valid (i.e. either the
+ object or the function is garbage collected). Should take a
+ single argument, which will be passed a pointer to this
+ object.
+ """
+
+ def remove(weak, self=self):
+ """Set self.isDead to True when method or instance is destroyed."""
+ methods = self.deletion_methods[:]
+ del self.deletion_methods[:]
+ try:
+ del self.__class__._all_instances[self.key]
+ except KeyError:
+ pass
+ for function in methods:
+ try:
+ if callable(function):
+ function(self)
+ except Exception:
+ try:
+ traceback.print_exc()
+ except AttributeError:
+ e = sys.exc_info()[1]
+ print(
+ f"Exception during saferef {self} "
+ f"cleanup function {function}: {e}"
+ )
+
+ self.deletion_methods = [on_delete]
+ self.key = self.calculate_key(target)
+ im_self = get_self(target)
+ im_func = get_func(target)
+ self.weak_self = weakref.ref(im_self, remove)
+ self.weak_func = weakref.ref(im_func, remove)
+ self.self_name = str(im_self)
+ self.func_name = str(im_func.__name__)
+
+ @classmethod
+ def calculate_key(cls, target):
+ """Calculate the reference key for this reference.
+
+ Currently this is a two-tuple of the id()'s of the target
+ object and the target function respectively.
+ """
+ return (id(get_self(target)), id(get_func(target)))
+
+ def __str__(self):
+ """Give a friendly representation of the object."""
+ return "{}({}.{})".format(
+ self.__class__.__name__,
+ self.self_name,
+ self.func_name,
+ )
+
+ __repr__ = __str__
+
+ def __hash__(self):
+ return hash((self.self_name, self.key))
+
+ def __nonzero__(self):
+ """Whether we are still a valid reference."""
+ return self() is not None
+
+ def __eq__(self, other):
+ """Compare with another reference."""
+ if not isinstance(other, self.__class__):
+ return operator.eq(self.__class__, type(other))
+ return operator.eq(self.key, other.key)
+
+ def __call__(self):
+ """Return a strong reference to the bound method.
+
+ If the target cannot be retrieved, then will return None,
+ otherwise returns a bound instance method for our object and
+ function.
+
+ Note: You may call this method any number of times, as it does
+ not invalidate the reference.
+ """
+ target = self.weak_self()
+ if target is not None:
+ function = self.weak_func()
+ if function is not None:
+ return function.__get__(target)
+ return None
diff --git a/server/venv/lib/python3.10/site-packages/blinker/_utilities.py b/server/venv/lib/python3.10/site-packages/blinker/_utilities.py
new file mode 100644
index 0000000..4b711c6
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/blinker/_utilities.py
@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import typing as t
+from weakref import ref
+
+from blinker._saferef import BoundMethodWeakref
+
+IdentityType = t.Union[t.Tuple[int, int], str, int]
+
+
+class _symbol:
+ def __init__(self, name):
+ """Construct a new named symbol."""
+ self.__name__ = self.name = name
+
+ def __reduce__(self):
+ return symbol, (self.name,)
+
+ def __repr__(self):
+ return self.name
+
+
+_symbol.__name__ = "symbol"
+
+
+class symbol:
+ """A constant symbol.
+
+ >>> symbol('foo') is symbol('foo')
+ True
+ >>> symbol('foo')
+ foo
+
+ A slight refinement of the MAGICCOOKIE=object() pattern. The primary
+ advantage of symbol() is its repr(). They are also singletons.
+
+ Repeated calls of symbol('name') will all return the same instance.
+
+ """
+
+ symbols = {} # type: ignore[var-annotated]
+
+ def __new__(cls, name):
+ try:
+ return cls.symbols[name]
+ except KeyError:
+ return cls.symbols.setdefault(name, _symbol(name))
+
+
+def hashable_identity(obj: object) -> IdentityType:
+ if hasattr(obj, "__func__"):
+ return (id(obj.__func__), id(obj.__self__)) # type: ignore[attr-defined]
+ elif hasattr(obj, "im_func"):
+ return (id(obj.im_func), id(obj.im_self)) # type: ignore[attr-defined]
+ elif isinstance(obj, (int, str)):
+ return obj
+ else:
+ return id(obj)
+
+
+WeakTypes = (ref, BoundMethodWeakref)
+
+
+class annotatable_weakref(ref):
+ """A weakref.ref that supports custom instance attributes."""
+
+ receiver_id: t.Optional[IdentityType]
+ sender_id: t.Optional[IdentityType]
+
+
+def reference( # type: ignore[no-untyped-def]
+ object, callback=None, **annotations
+) -> annotatable_weakref:
+ """Return an annotated weak ref."""
+ if callable(object):
+ weak = callable_reference(object, callback)
+ else:
+ weak = annotatable_weakref(object, callback)
+ for key, value in annotations.items():
+ setattr(weak, key, value)
+ return weak # type: ignore[no-any-return]
+
+
+def callable_reference(object, callback=None):
+ """Return an annotated weak ref, supporting bound instance methods."""
+ if hasattr(object, "im_self") and object.im_self is not None:
+ return BoundMethodWeakref(target=object, on_delete=callback)
+ elif hasattr(object, "__self__") and object.__self__ is not None:
+ return BoundMethodWeakref(target=object, on_delete=callback)
+ return annotatable_weakref(object, callback)
+
+
+class lazy_property:
+ """A @property that is only evaluated once."""
+
+ def __init__(self, deferred):
+ self._deferred = deferred
+ self.__doc__ = deferred.__doc__
+
+ def __get__(self, obj, cls):
+ if obj is None:
+ return self
+ value = self._deferred(obj)
+ setattr(obj, self._deferred.__name__, value)
+ return value
diff --git a/server/venv/lib/python3.10/site-packages/blinker/base.py b/server/venv/lib/python3.10/site-packages/blinker/base.py
new file mode 100644
index 0000000..b9d7035
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/blinker/base.py
@@ -0,0 +1,558 @@
+"""Signals and events.
+
+A small implementation of signals, inspired by a snippet of Django signal
+API client code seen in a blog post. Signals are first-class objects and
+each manages its own receivers and message emission.
+
+The :func:`signal` function provides singleton behavior for named signals.
+
+"""
+from __future__ import annotations
+
+import typing as t
+from collections import defaultdict
+from contextlib import contextmanager
+from inspect import iscoroutinefunction
+from warnings import warn
+from weakref import WeakValueDictionary
+
+from blinker._utilities import annotatable_weakref
+from blinker._utilities import hashable_identity
+from blinker._utilities import IdentityType
+from blinker._utilities import lazy_property
+from blinker._utilities import reference
+from blinker._utilities import symbol
+from blinker._utilities import WeakTypes
+
+if t.TYPE_CHECKING:
+ import typing_extensions as te
+
+ T_callable = t.TypeVar("T_callable", bound=t.Callable[..., t.Any])
+
+ T = t.TypeVar("T")
+ P = te.ParamSpec("P")
+
+ AsyncWrapperType = t.Callable[[t.Callable[P, t.Awaitable[T]]], t.Callable[P, T]]
+ SyncWrapperType = t.Callable[[t.Callable[P, T]], t.Callable[P, t.Awaitable[T]]]
+
+ANY = symbol("ANY")
+ANY.__doc__ = 'Token for "any sender".'
+ANY_ID = 0
+
+# NOTE: We need a reference to cast for use in weakref callbacks otherwise
+# t.cast may have already been set to None during finalization.
+cast = t.cast
+
+
+class Signal:
+ """A notification emitter."""
+
+ #: An :obj:`ANY` convenience synonym, allows ``Signal.ANY``
+ #: without an additional import.
+ ANY = ANY
+
+ set_class: type[set] = set
+
+ @lazy_property
+ def receiver_connected(self) -> Signal:
+ """Emitted after each :meth:`connect`.
+
+ The signal sender is the signal instance, and the :meth:`connect`
+ arguments are passed through: *receiver*, *sender*, and *weak*.
+
+ .. versionadded:: 1.2
+
+ """
+ return Signal(doc="Emitted after a receiver connects.")
+
+ @lazy_property
+ def receiver_disconnected(self) -> Signal:
+ """Emitted after :meth:`disconnect`.
+
+ The sender is the signal instance, and the :meth:`disconnect` arguments
+ are passed through: *receiver* and *sender*.
+
+ Note, this signal is emitted **only** when :meth:`disconnect` is
+ called explicitly.
+
+ The disconnect signal can not be emitted by an automatic disconnect
+ (due to a weakly referenced receiver or sender going out of scope),
+ as the receiver and/or sender instances are no longer available for
+ use at the time this signal would be emitted.
+
+ An alternative approach is available by subscribing to
+ :attr:`receiver_connected` and setting up a custom weakref cleanup
+ callback on weak receivers and senders.
+
+ .. versionadded:: 1.2
+
+ """
+ return Signal(doc="Emitted after a receiver disconnects.")
+
+ def __init__(self, doc: str | None = None) -> None:
+ """
+ :param doc: optional. If provided, will be assigned to the signal's
+ __doc__ attribute.
+
+ """
+ if doc:
+ self.__doc__ = doc
+ #: A mapping of connected receivers.
+ #:
+ #: The values of this mapping are not meaningful outside of the
+ #: internal :class:`Signal` implementation, however the boolean value
+ #: of the mapping is useful as an extremely efficient check to see if
+ #: any receivers are connected to the signal.
+ self.receivers: dict[IdentityType, t.Callable | annotatable_weakref] = {}
+ self.is_muted = False
+ self._by_receiver: dict[IdentityType, set[IdentityType]] = defaultdict(
+ self.set_class
+ )
+ self._by_sender: dict[IdentityType, set[IdentityType]] = defaultdict(
+ self.set_class
+ )
+ self._weak_senders: dict[IdentityType, annotatable_weakref] = {}
+
+ def connect(
+ self, receiver: T_callable, sender: t.Any = ANY, weak: bool = True
+ ) -> T_callable:
+ """Connect *receiver* to signal events sent by *sender*.
+
+ :param receiver: A callable. Will be invoked by :meth:`send` with
+ `sender=` as a single positional argument and any ``kwargs`` that
+ were provided to a call to :meth:`send`.
+
+ :param sender: Any object or :obj:`ANY`, defaults to ``ANY``.
+ Restricts notifications delivered to *receiver* to only those
+ :meth:`send` emissions sent by *sender*. If ``ANY``, the receiver
+ will always be notified. A *receiver* may be connected to
+ multiple *sender* values on the same Signal through multiple calls
+ to :meth:`connect`.
+
+ :param weak: If true, the Signal will hold a weakref to *receiver*
+ and automatically disconnect when *receiver* goes out of scope or
+ is garbage collected. Defaults to True.
+
+ """
+ receiver_id = hashable_identity(receiver)
+ receiver_ref: T_callable | annotatable_weakref
+
+ if weak:
+ receiver_ref = reference(receiver, self._cleanup_receiver)
+ receiver_ref.receiver_id = receiver_id
+ else:
+ receiver_ref = receiver
+ sender_id: IdentityType
+ if sender is ANY:
+ sender_id = ANY_ID
+ else:
+ sender_id = hashable_identity(sender)
+
+ self.receivers.setdefault(receiver_id, receiver_ref)
+ self._by_sender[sender_id].add(receiver_id)
+ self._by_receiver[receiver_id].add(sender_id)
+ del receiver_ref
+
+ if sender is not ANY and sender_id not in self._weak_senders:
+ # wire together a cleanup for weakref-able senders
+ try:
+ sender_ref = reference(sender, self._cleanup_sender)
+ sender_ref.sender_id = sender_id
+ except TypeError:
+ pass
+ else:
+ self._weak_senders.setdefault(sender_id, sender_ref)
+ del sender_ref
+
+ # broadcast this connection. if receivers raise, disconnect.
+ if "receiver_connected" in self.__dict__ and self.receiver_connected.receivers:
+ try:
+ self.receiver_connected.send(
+ self, receiver=receiver, sender=sender, weak=weak
+ )
+ except TypeError as e:
+ self.disconnect(receiver, sender)
+ raise e
+ if receiver_connected.receivers and self is not receiver_connected:
+ try:
+ receiver_connected.send(
+ self, receiver_arg=receiver, sender_arg=sender, weak_arg=weak
+ )
+ except TypeError as e:
+ self.disconnect(receiver, sender)
+ raise e
+ return receiver
+
+ def connect_via(
+ self, sender: t.Any, weak: bool = False
+ ) -> t.Callable[[T_callable], T_callable]:
+ """Connect the decorated function as a receiver for *sender*.
+
+ :param sender: Any object or :obj:`ANY`. The decorated function
+ will only receive :meth:`send` emissions sent by *sender*. If
+ ``ANY``, the receiver will always be notified. A function may be
+ decorated multiple times with differing *sender* values.
+
+ :param weak: If true, the Signal will hold a weakref to the
+ decorated function and automatically disconnect when *receiver*
+ goes out of scope or is garbage collected. Unlike
+ :meth:`connect`, this defaults to False.
+
+ The decorated function will be invoked by :meth:`send` with
+ `sender=` as a single positional argument and any ``kwargs`` that
+ were provided to the call to :meth:`send`.
+
+
+ .. versionadded:: 1.1
+
+ """
+
+ def decorator(fn: T_callable) -> T_callable:
+ self.connect(fn, sender, weak)
+ return fn
+
+ return decorator
+
+ @contextmanager
+ def connected_to(
+ self, receiver: t.Callable, sender: t.Any = ANY
+ ) -> t.Generator[None, None, None]:
+ """Execute a block with the signal temporarily connected to *receiver*.
+
+ :param receiver: a receiver callable
+ :param sender: optional, a sender to filter on
+
+ This is a context manager for use in the ``with`` statement. It can
+ be useful in unit tests. *receiver* is connected to the signal for
+ the duration of the ``with`` block, and will be disconnected
+ automatically when exiting the block:
+
+ .. code-block:: python
+
+ with on_ready.connected_to(receiver):
+ # do stuff
+ on_ready.send(123)
+
+ .. versionadded:: 1.1
+
+ """
+ self.connect(receiver, sender=sender, weak=False)
+ try:
+ yield None
+ finally:
+ self.disconnect(receiver)
+
+ @contextmanager
+ def muted(self) -> t.Generator[None, None, None]:
+ """Context manager for temporarily disabling signal.
+ Useful for test purposes.
+ """
+ self.is_muted = True
+ try:
+ yield None
+ except Exception as e:
+ raise e
+ finally:
+ self.is_muted = False
+
+ def temporarily_connected_to(
+ self, receiver: t.Callable, sender: t.Any = ANY
+ ) -> t.ContextManager[None]:
+ """An alias for :meth:`connected_to`.
+
+ :param receiver: a receiver callable
+ :param sender: optional, a sender to filter on
+
+ .. versionadded:: 0.9
+
+ .. versionchanged:: 1.1
+ Renamed to :meth:`connected_to`. ``temporarily_connected_to`` was
+ deprecated in 1.2 and will be removed in a subsequent version.
+
+ """
+ warn(
+ "temporarily_connected_to is deprecated; use connected_to instead.",
+ DeprecationWarning,
+ )
+ return self.connected_to(receiver, sender)
+
+ def send(
+ self,
+ *sender: t.Any,
+ _async_wrapper: AsyncWrapperType | None = None,
+ **kwargs: t.Any,
+ ) -> list[tuple[t.Callable, t.Any]]:
+ """Emit this signal on behalf of *sender*, passing on ``kwargs``.
+
+ Returns a list of 2-tuples, pairing receivers with their return
+ value. The ordering of receiver notification is undefined.
+
+ :param sender: Any object or ``None``. If omitted, synonymous
+ with ``None``. Only accepts one positional argument.
+ :param _async_wrapper: A callable that should wrap a coroutine
+ receiver and run it when called synchronously.
+
+ :param kwargs: Data to be sent to receivers.
+ """
+ if self.is_muted:
+ return []
+
+ sender = self._extract_sender(sender)
+ results = []
+ for receiver in self.receivers_for(sender):
+ if iscoroutinefunction(receiver):
+ if _async_wrapper is None:
+ raise RuntimeError("Cannot send to a coroutine function")
+ receiver = _async_wrapper(receiver)
+ result = receiver(sender, **kwargs)
+ results.append((receiver, result))
+ return results
+
+ async def send_async(
+ self,
+ *sender: t.Any,
+ _sync_wrapper: SyncWrapperType | None = None,
+ **kwargs: t.Any,
+ ) -> list[tuple[t.Callable, t.Any]]:
+ """Emit this signal on behalf of *sender*, passing on ``kwargs``.
+
+ Returns a list of 2-tuples, pairing receivers with their return
+ value. The ordering of receiver notification is undefined.
+
+ :param sender: Any object or ``None``. If omitted, synonymous
+ with ``None``. Only accepts one positional argument.
+ :param _sync_wrapper: A callable that should wrap a synchronous
+ receiver and run it when awaited.
+
+ :param kwargs: Data to be sent to receivers.
+ """
+ if self.is_muted:
+ return []
+
+ sender = self._extract_sender(sender)
+ results = []
+ for receiver in self.receivers_for(sender):
+ if not iscoroutinefunction(receiver):
+ if _sync_wrapper is None:
+ raise RuntimeError("Cannot send to a non-coroutine function")
+ receiver = _sync_wrapper(receiver)
+ result = await receiver(sender, **kwargs)
+ results.append((receiver, result))
+ return results
+
+ def _extract_sender(self, sender: t.Any) -> t.Any:
+ if not self.receivers:
+ # Ensure correct signature even on no-op sends, disable with -O
+ # for lowest possible cost.
+ if __debug__ and sender and len(sender) > 1:
+ raise TypeError(
+ f"send() accepts only one positional argument, {len(sender)} given"
+ )
+ return []
+
+ # Using '*sender' rather than 'sender=None' allows 'sender' to be
+ # used as a keyword argument- i.e. it's an invisible name in the
+ # function signature.
+ if len(sender) == 0:
+ sender = None
+ elif len(sender) > 1:
+ raise TypeError(
+ f"send() accepts only one positional argument, {len(sender)} given"
+ )
+ else:
+ sender = sender[0]
+ return sender
+
+ def has_receivers_for(self, sender: t.Any) -> bool:
+ """True if there is probably a receiver for *sender*.
+
+ Performs an optimistic check only. Does not guarantee that all
+ weakly referenced receivers are still alive. See
+ :meth:`receivers_for` for a stronger search.
+
+ """
+ if not self.receivers:
+ return False
+ if self._by_sender[ANY_ID]:
+ return True
+ if sender is ANY:
+ return False
+ return hashable_identity(sender) in self._by_sender
+
+ def receivers_for(
+ self, sender: t.Any
+ ) -> t.Generator[t.Callable[[t.Any], t.Any], None, None]:
+ """Iterate all live receivers listening for *sender*."""
+ # TODO: test receivers_for(ANY)
+ if self.receivers:
+ sender_id = hashable_identity(sender)
+ if sender_id in self._by_sender:
+ ids = self._by_sender[ANY_ID] | self._by_sender[sender_id]
+ else:
+ ids = self._by_sender[ANY_ID].copy()
+ for receiver_id in ids:
+ receiver = self.receivers.get(receiver_id)
+ if receiver is None:
+ continue
+ if isinstance(receiver, WeakTypes):
+ strong = receiver()
+ if strong is None:
+ self._disconnect(receiver_id, ANY_ID)
+ continue
+ receiver = strong
+ yield receiver # type: ignore[misc]
+
+ def disconnect(self, receiver: t.Callable, sender: t.Any = ANY) -> None:
+ """Disconnect *receiver* from this signal's events.
+
+ :param receiver: a previously :meth:`connected` callable
+
+ :param sender: a specific sender to disconnect from, or :obj:`ANY`
+ to disconnect from all senders. Defaults to ``ANY``.
+
+ """
+ sender_id: IdentityType
+ if sender is ANY:
+ sender_id = ANY_ID
+ else:
+ sender_id = hashable_identity(sender)
+ receiver_id = hashable_identity(receiver)
+ self._disconnect(receiver_id, sender_id)
+
+ if (
+ "receiver_disconnected" in self.__dict__
+ and self.receiver_disconnected.receivers
+ ):
+ self.receiver_disconnected.send(self, receiver=receiver, sender=sender)
+
+ def _disconnect(self, receiver_id: IdentityType, sender_id: IdentityType) -> None:
+ if sender_id == ANY_ID:
+ if self._by_receiver.pop(receiver_id, False):
+ for bucket in self._by_sender.values():
+ bucket.discard(receiver_id)
+ self.receivers.pop(receiver_id, None)
+ else:
+ self._by_sender[sender_id].discard(receiver_id)
+ self._by_receiver[receiver_id].discard(sender_id)
+
+ def _cleanup_receiver(self, receiver_ref: annotatable_weakref) -> None:
+ """Disconnect a receiver from all senders."""
+ self._disconnect(cast(IdentityType, receiver_ref.receiver_id), ANY_ID)
+
+ def _cleanup_sender(self, sender_ref: annotatable_weakref) -> None:
+ """Disconnect all receivers from a sender."""
+ sender_id = cast(IdentityType, sender_ref.sender_id)
+ assert sender_id != ANY_ID
+ self._weak_senders.pop(sender_id, None)
+ for receiver_id in self._by_sender.pop(sender_id, ()):
+ self._by_receiver[receiver_id].discard(sender_id)
+
+ def _cleanup_bookkeeping(self) -> None:
+ """Prune unused sender/receiver bookkeeping. Not threadsafe.
+
+ Connecting & disconnecting leave behind a small amount of bookkeeping
+ for the receiver and sender values. Typical workloads using Blinker,
+ for example in most web apps, Flask, CLI scripts, etc., are not
+ adversely affected by this bookkeeping.
+
+ With a long-running Python process performing dynamic signal routing
+ with high volume- e.g. connecting to function closures, "senders" are
+ all unique object instances, and doing all of this over and over- you
+ may see memory usage will grow due to extraneous bookkeeping. (An empty
+ set() for each stale sender/receiver pair.)
+
+ This method will prune that bookkeeping away, with the caveat that such
+ pruning is not threadsafe. The risk is that cleanup of a fully
+ disconnected receiver/sender pair occurs while another thread is
+ connecting that same pair. If you are in the highly dynamic, unique
+ receiver/sender situation that has lead you to this method, that
+ failure mode is perhaps not a big deal for you.
+ """
+ for mapping in (self._by_sender, self._by_receiver):
+ for _id, bucket in list(mapping.items()):
+ if not bucket:
+ mapping.pop(_id, None)
+
+ def _clear_state(self) -> None:
+ """Throw away all signal state. Useful for unit tests."""
+ self._weak_senders.clear()
+ self.receivers.clear()
+ self._by_sender.clear()
+ self._by_receiver.clear()
+
+
+receiver_connected = Signal(
+ """\
+Sent by a :class:`Signal` after a receiver connects.
+
+:argument: the Signal that was connected to
+:keyword receiver_arg: the connected receiver
+:keyword sender_arg: the sender to connect to
+:keyword weak_arg: true if the connection to receiver_arg is a weak reference
+
+.. deprecated:: 1.2
+
+As of 1.2, individual signals have their own private
+:attr:`~Signal.receiver_connected` and
+:attr:`~Signal.receiver_disconnected` signals with a slightly simplified
+call signature. This global signal is planned to be removed in 1.6.
+
+"""
+)
+
+
+class NamedSignal(Signal):
+ """A named generic notification emitter."""
+
+ def __init__(self, name: str, doc: str | None = None) -> None:
+ Signal.__init__(self, doc)
+
+ #: The name of this signal.
+ self.name = name
+
+ def __repr__(self) -> str:
+ base = Signal.__repr__(self)
+ return f"{base[:-1]}; {self.name!r}>" # noqa: E702
+
+
+class Namespace(dict):
+ """A mapping of signal names to signals."""
+
+ def signal(self, name: str, doc: str | None = None) -> NamedSignal:
+ """Return the :class:`NamedSignal` *name*, creating it if required.
+
+ Repeated calls to this function will return the same signal object.
+
+ """
+ try:
+ return self[name] # type: ignore[no-any-return]
+ except KeyError:
+ result = self.setdefault(name, NamedSignal(name, doc))
+ return result # type: ignore[no-any-return]
+
+
+class WeakNamespace(WeakValueDictionary):
+ """A weak mapping of signal names to signals.
+
+ Automatically cleans up unused Signals when the last reference goes out
+ of scope. This namespace implementation exists for a measure of legacy
+ compatibility with Blinker <= 1.2, and may be dropped in the future.
+
+ .. versionadded:: 1.3
+
+ """
+
+ def signal(self, name: str, doc: str | None = None) -> NamedSignal:
+ """Return the :class:`NamedSignal` *name*, creating it if required.
+
+ Repeated calls to this function will return the same signal object.
+
+ """
+ try:
+ return self[name] # type: ignore[no-any-return]
+ except KeyError:
+ result = self.setdefault(name, NamedSignal(name, doc))
+ return result # type: ignore[no-any-return]
+
+
+signal = Namespace().signal
diff --git a/server/venv/lib/python3.10/site-packages/blinker/py.typed b/server/venv/lib/python3.10/site-packages/blinker/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/INSTALLER b/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/INSTALLER
new file mode 100644
index 0000000..a1b589e
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/LICENSE.rst b/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/LICENSE.rst
new file mode 100644
index 0000000..d12a849
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/LICENSE.rst
@@ -0,0 +1,28 @@
+Copyright 2014 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+2. 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.
+
+3. Neither the name of the copyright holder 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.
diff --git a/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/METADATA b/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/METADATA
new file mode 100644
index 0000000..7a6bbb2
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/METADATA
@@ -0,0 +1,103 @@
+Metadata-Version: 2.1
+Name: click
+Version: 8.1.7
+Summary: Composable command line interface toolkit
+Home-page: https://palletsprojects.com/p/click/
+Maintainer: Pallets
+Maintainer-email: contact@palletsprojects.com
+License: BSD-3-Clause
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://click.palletsprojects.com/
+Project-URL: Changes, https://click.palletsprojects.com/changes/
+Project-URL: Source Code, https://github.com/pallets/click/
+Project-URL: Issue Tracker, https://github.com/pallets/click/issues/
+Project-URL: Chat, https://discord.gg/pallets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+Requires-Dist: colorama ; platform_system == "Windows"
+Requires-Dist: importlib-metadata ; python_version < "3.8"
+
+\$ click\_
+==========
+
+Click is a Python package for creating beautiful command line interfaces
+in a composable way with as little code as necessary. It's the "Command
+Line Interface Creation Kit". It's highly configurable but comes with
+sensible defaults out of the box.
+
+It aims to make the process of writing command line tools quick and fun
+while also preventing any frustration caused by the inability to
+implement an intended CLI API.
+
+Click in three points:
+
+- Arbitrary nesting of commands
+- Automatic help page generation
+- Supports lazy loading of subcommands at runtime
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+ $ pip install -U click
+
+.. _pip: https://pip.pypa.io/en/stable/getting-started/
+
+
+A Simple Example
+----------------
+
+.. code-block:: python
+
+ import click
+
+ @click.command()
+ @click.option("--count", default=1, help="Number of greetings.")
+ @click.option("--name", prompt="Your name", help="The person to greet.")
+ def hello(count, name):
+ """Simple program that greets NAME for a total of COUNT times."""
+ for _ in range(count):
+ click.echo(f"Hello, {name}!")
+
+ if __name__ == '__main__':
+ hello()
+
+.. code-block:: text
+
+ $ python hello.py --count=3
+ Your name: Click
+ Hello, Click!
+ Hello, Click!
+ Hello, Click!
+
+
+Donate
+------
+
+The Pallets organization develops and supports Click and other popular
+packages. In order to grow the community of contributors and users, and
+allow the maintainers to devote more time to the projects, `please
+donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+- Documentation: https://click.palletsprojects.com/
+- Changes: https://click.palletsprojects.com/changes/
+- PyPI Releases: https://pypi.org/project/click/
+- Source Code: https://github.com/pallets/click
+- Issue Tracker: https://github.com/pallets/click/issues
+- Chat: https://discord.gg/pallets
diff --git a/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/RECORD b/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/RECORD
new file mode 100644
index 0000000..3ff0797
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/RECORD
@@ -0,0 +1,39 @@
+click-8.1.7.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+click-8.1.7.dist-info/LICENSE.rst,sha256=morRBqOU6FO_4h9C9OctWSgZoigF2ZG18ydQKSkrZY0,1475
+click-8.1.7.dist-info/METADATA,sha256=qIMevCxGA9yEmJOM_4WHuUJCwWpsIEVbCPOhs45YPN4,3014
+click-8.1.7.dist-info/RECORD,,
+click-8.1.7.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
+click-8.1.7.dist-info/top_level.txt,sha256=J1ZQogalYS4pphY_lPECoNMfw0HzTSrZglC4Yfwo4xA,6
+click/__init__.py,sha256=YDDbjm406dTOA0V8bTtdGnhN7zj5j-_dFRewZF_pLvw,3138
+click/__pycache__/__init__.cpython-310.pyc,,
+click/__pycache__/_compat.cpython-310.pyc,,
+click/__pycache__/_termui_impl.cpython-310.pyc,,
+click/__pycache__/_textwrap.cpython-310.pyc,,
+click/__pycache__/_winconsole.cpython-310.pyc,,
+click/__pycache__/core.cpython-310.pyc,,
+click/__pycache__/decorators.cpython-310.pyc,,
+click/__pycache__/exceptions.cpython-310.pyc,,
+click/__pycache__/formatting.cpython-310.pyc,,
+click/__pycache__/globals.cpython-310.pyc,,
+click/__pycache__/parser.cpython-310.pyc,,
+click/__pycache__/shell_completion.cpython-310.pyc,,
+click/__pycache__/termui.cpython-310.pyc,,
+click/__pycache__/testing.cpython-310.pyc,,
+click/__pycache__/types.cpython-310.pyc,,
+click/__pycache__/utils.cpython-310.pyc,,
+click/_compat.py,sha256=5318agQpbt4kroKsbqDOYpTSWzL_YCZVUQiTT04yXmc,18744
+click/_termui_impl.py,sha256=3dFYv4445Nw-rFvZOTBMBPYwB1bxnmNk9Du6Dm_oBSU,24069
+click/_textwrap.py,sha256=10fQ64OcBUMuK7mFvh8363_uoOxPlRItZBmKzRJDgoY,1353
+click/_winconsole.py,sha256=5ju3jQkcZD0W27WEMGqmEP4y_crUVzPCqsX_FYb7BO0,7860
+click/core.py,sha256=j6oEWtGgGna8JarD6WxhXmNnxLnfRjwXglbBc-8jr7U,114086
+click/decorators.py,sha256=-ZlbGYgV-oI8jr_oH4RpuL1PFS-5QmeuEAsLDAYgxtw,18719
+click/exceptions.py,sha256=fyROO-47HWFDjt2qupo7A3J32VlpM-ovJnfowu92K3s,9273
+click/formatting.py,sha256=Frf0-5W33-loyY_i9qrwXR8-STnW3m5gvyxLVUdyxyk,9706
+click/globals.py,sha256=TP-qM88STzc7f127h35TD_v920FgfOD2EwzqA0oE8XU,1961
+click/parser.py,sha256=LKyYQE9ZLj5KgIDXkrcTHQRXIggfoivX14_UVIn56YA,19067
+click/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+click/shell_completion.py,sha256=Ty3VM_ts0sQhj6u7eFTiLwHPoTgcXTGEAUg2OpLqYKw,18460
+click/termui.py,sha256=H7Q8FpmPelhJ2ovOhfCRhjMtCpNyjFXryAMLZODqsdc,28324
+click/testing.py,sha256=1Qd4kS5bucn1hsNIRryd0WtTMuCpkA93grkWxT8POsU,16084
+click/types.py,sha256=TZvz3hKvBztf-Hpa2enOmP4eznSPLzijjig5b_0XMxE,36391
+click/utils.py,sha256=1476UduUNY6UePGU4m18uzVHLt1sKM2PP3yWsQhbItM,20298
diff --git a/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/WHEEL b/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/WHEEL
new file mode 100644
index 0000000..2c08da0
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/top_level.txt b/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/top_level.txt
new file mode 100644
index 0000000..dca9a90
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/click-8.1.7.dist-info/top_level.txt
@@ -0,0 +1 @@
+click
diff --git a/server/venv/lib/python3.10/site-packages/click/__init__.py b/server/venv/lib/python3.10/site-packages/click/__init__.py
new file mode 100644
index 0000000..9a1dab0
--- /dev/null
+++ b/server/venv/lib/python3.10/site-packages/click/__init__.py
@@ -0,0 +1,73 @@
+"""
+Click is a simple Python module inspired by the stdlib optparse to make
+writing command line scripts fun. Unlike other modules, it's based
+around a simple API that does not come with too much magic and is
+composable.
+"""
+from .core import Argument as Argument
+from .core import BaseCommand as BaseCommand
+from .core import Command as Command
+from .core import CommandCollection as CommandCollection
+from .core import Context as Context
+from .core import Group as Group
+from .core import MultiCommand as MultiCommand
+from .core import Option as Option
+from .core import Parameter as Parameter
+from .decorators import argument as argument
+from .decorators import command as command
+from .decorators import confirmation_option as confirmation_option
+from .decorators import group as group
+from .decorators import help_option as help_option
+from .decorators import make_pass_decorator as make_pass_decorator
+from .decorators import option as option
+from .decorators import pass_context as pass_context
+from .decorators import pass_obj as pass_obj
+from .decorators import password_option as password_option
+from .decorators import version_option as version_option
+from .exceptions import Abort as Abort
+from .exceptions import BadArgumentUsage as BadArgumentUsage
+from .exceptions import BadOptionUsage as BadOptionUsage
+from .exceptions import BadParameter as BadParameter
+from .exceptions import ClickException as ClickException
+from .exceptions import FileError as FileError
+from .exceptions import MissingParameter as MissingParameter
+from .exceptions import NoSuchOption as NoSuchOption
+from .exceptions import UsageError as UsageError
+from .formatting import HelpFormatter as HelpFormatter
+from .formatting import wrap_text as wrap_text
+from .globals import get_current_context as get_current_context
+from .parser import OptionParser as OptionParser
+from .termui import clear as clear
+from .termui import confirm as confirm
+from .termui import echo_via_pager as echo_via_pager
+from .termui import edit as edit
+from .termui import getchar as getchar
+from .termui import launch as launch
+from .termui import pause as pause
+from .termui import progressbar as progressbar
+from .termui import prompt as prompt
+from .termui import secho as secho
+from .termui import style as style
+from .termui import unstyle as unstyle
+from .types import BOOL as BOOL
+from .types import Choice as Choice
+from .types import DateTime as DateTime
+from .types import File as File
+from .types import FLOAT as FLOAT
+from .types import FloatRange as FloatRange
+from .types import INT as INT
+from .types import IntRange as IntRange
+from .types import ParamType as ParamType
+from .types import Path as Path
+from .types import STRING as STRING
+from .types import Tuple as Tuple
+from .types import UNPROCESSED as UNPROCESSED
+from .types import UUID as UUID
+from .utils import echo as echo
+from .utils import format_filename as format_filename
+from .utils import get_app_dir as get_app_dir
+from .utils import get_binary_stream as get_binary_stream
+from .utils import get_text_stream as get_text_stream
+from .utils import open_file as open_file
+
+__version__ = "8.1.7"
diff --git a/server/venv/lib/python3.10/site-packages/click/__pycache__/__init__.cpython-310.pyc b/server/venv/lib/python3.10/site-packages/click/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..046903e0efc00cdb1165b09143181153adf3f29e
GIT binary patch
literal 2629
zcmc)M*-{%v6b4`c+9meItY!?xm`!3c`zDFSI5toQZce3Ysx@k)F|$?o2uvOz?~q4G
zRbD4Iy3JKyAy+x)h{bt=;PTJct?BNWGd&vo_V#oHfByLMH(AU^B7afi$DdYg9N>RF
z*cORYA`q#xR9c-Dw-s7j$ZhC0Xk$mwQHZi*=orM;yUi33d{lgd{tKPC<&D
zMyDao&Nvx23t4s+-45;Sc60}HushJ5(8=yZcR?4s3*8Of>~3@q^ssx-z0k|9pvPd0J&Jw}ui0bh
zaTsU6MjK$T$DKFs1Wd3E^dwBO-#BmGDVSnUIPctPm}XBp@7)=gVZTMs!Yq3VJqL5_
zcj$STXHTOSV1fM}or4^E2AzjIdltP2i|je{5-hRj(aW&RUO=zF3Ok2hg;jRm`QWa>
z8ha7F4(seC^agCOm(iQB$zDNk!4`WJy$##!59l4(VXvWgVVAv*-h(~%26`X%*_-GC
zIACv~3s7Khql-{v@1RRiV(&VK?hzcZ_t3|1%-%R{SiL03+PigWf#$(;1jw8
zKUEGdBQr<8G}0xCT8#i??XIy)ZeJc$gXHk!{>v_Wt
zr?pWQT2|6R`E?xmd?JO5Q(RJnM#Y!f@cfV_m&Uyv)^J%|w{F#N@v3bZw4$xk_<7)K
zQFdf5{dWsK|1&L(WIE(JE`=4S1y!&MHkpr
z6qTn+U29R5*w=x5&C7f0$zsosm)XJF=jgj7pDrbJY&-HuDL&DzFSgdWD}Ef3J@YT|
z#yyuU&2vAEX#a=>IQFSR%|fQ`l?cqo%j>Pm(6s7G;q5eEt~%SC3|G-y{FvoPL50G~
zbGhkSq*e3HJ6m8mt9(>cR&2WR1Wszz`1rUZ>Yi1@&R8Jonre^vHo5Y`OvO
z2u(B6p*nnU=+H#ndt$VBe*PJ|;-#8zTl8V_P=xZzcF9qy5&n)He?Bi6D=)O+q~?yakbfQMg*kj^oFdG+=5?1Uz|s^gQ3$XuUYd_6B6U0xm?Vl#Su
zeagQdPqp)gD{J21`X2688bKu$L10#Fs#rHQ%eE)fgQ-I$g^Qh?)JeDCr7PtJ(&Kr4
ziEZSTa_eU^pBo9&toW8`Hlny!rJ|Rx!uM}PMJZwwaf$>*k|ISxukuFvd4p?}p;*|QhcCTqgbcdpxC6?qS&U`!Dz(lp^ay{OC5U@`xFNh1&Sg@
zBV(FR&%gP5M4izG6#x93ui+PK{+rOgm%sFH!h4}){>BmdcEQ8j{!Qoc!NRfmJL%o!
z@%uj?@JnJPx3rkob|@DDVcp_$rSlfOPx7W|dv<7=x!|FZ+-bf_@a>0xko}4gjb!85
KmjCx(vh`o0Pq@4Q
literal 0
HcmV?d00001
diff --git a/server/venv/lib/python3.10/site-packages/click/__pycache__/_compat.cpython-310.pyc b/server/venv/lib/python3.10/site-packages/click/__pycache__/_compat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c5bae8642841179d026d148bef70cffc986af342
GIT binary patch
literal 15687
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
D=~1a8
literal 0
HcmV?d00001
diff --git a/server/venv/lib/python3.10/site-packages/click/__pycache__/_termui_impl.cpython-310.pyc b/server/venv/lib/python3.10/site-packages/click/__pycache__/_termui_impl.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8f815eaf01b63e7a6b0997115d0e60a94de8004b
GIT binary patch
literal 16327
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