txredisapi 1.5.0__tar.gz → 1.6.0__tar.gz

{txredisapi-1.5.0/txredisapi.egg-info → txredisapi-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: txredisapi
-Version: 1.5.0
+Version: 1.6.0
 Summary: non-blocking redis client for python
 Home-page: http://github.com/IlyaSkriblovsky/txredisapi
 Author: Alexandre Fiori
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.5
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: twisted[tls]
+Requires-Dist: twisted[tls]>=18.7.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{txredisapi-1.5.0 → txredisapi-1.6.0}/setup.py

@@ -23,9 +23,9 @@ long_description = (this_directory / "README.md").read_text()
 
 setuptools.setup(
     name="txredisapi",
-    version="1.5.0",
+    version="1.6.0",
     py_modules=["txredisapi"],
-    install_requires=["twisted[tls]"],
+    install_requires=["twisted[tls]>=18.7.0"],
     python_requires=">=3.5",
     author="Alexandre Fiori",
     author_email="fiorix@gmail.com",

txredisapi-1.6.0/tests/test_ipv6.py

@@ -0,0 +1,98 @@
+# coding: utf-8
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from twisted.internet import defer, reactor
+from twisted.internet.address import IPv6Address
+from twisted.internet.error import CannotListenError
+from twisted.internet.interfaces import IHostnameResolver, IHostResolution
+from twisted.trial import unittest
+from zope.interface import implementer
+
+import txredisapi as redis
+
+from tests.test_sentinel import FakeRedisFactory
+
+
+@implementer(IHostResolution)
+class Resolution(object):
+    def __init__(self, name):
+        self.name = name
+
+    def cancel(self):
+        pass
+
+
+@implementer(IHostnameResolver)
+class IPv6OnlyResolver(object):
+    """
+    Resolves a single hostname to a single IPv6 address and knows nothing
+    else, just like a name that has an AAAA record and no A record.
+    """
+
+    def __init__(self, hostname, address="::1"):
+        self.hostname = hostname
+        self.address = address
+
+    def resolveHostName(self, resolutionReceiver, hostName, portNumber=0,
+                        addressTypes=None, transportSemantics="TCP"):
+        resolution = Resolution(hostName)
+        resolutionReceiver.resolutionBegan(resolution)
+        if hostName == self.hostname and \
+                (addressTypes is None or IPv6Address in addressTypes):
+            resolutionReceiver.addressResolved(
+                IPv6Address("TCP", self.address, portNumber))
+        resolutionReceiver.resolutionComplete()
+        return resolution
+
+
+class TestIPv6Connections(unittest.TestCase):
+    """
+    Servers reachable over IPv6 only must be reachable as well: names are
+    resolved with getaddrinfo(), not with the IPv4-only gethostbyname().
+    """
+
+    hostname = "ipv6-only.invalid"
+
+    # connecting to the loopback is instant; don't sit through trial's default
+    # timeout if it ever stops working
+    timeout = 15
+
+    def setUp(self):
+        try:
+            self.listener = reactor.listenTCP(0, FakeRedisFactory(),
+                                              interface="::1")
+        except CannotListenError:
+            raise unittest.SkipTest("no IPv6 loopback available")
+
+        self.port = self.listener.getHost().port
+        self.addCleanup(self.listener.stopListening)
+
+    @defer.inlineCallbacks
+    def test_aaaa_only_hostname(self):
+        previous = reactor.installNameResolver(IPv6OnlyResolver(self.hostname))
+        self.addCleanup(reactor.installNameResolver, previous)
+
+        db = yield redis.Connection(self.hostname, self.port, reconnect=False)
+        self.addCleanup(db.disconnect)
+
+        role = yield db.role()
+        self.assertEqual(role[0], "master")
+
+    @defer.inlineCallbacks
+    def test_ipv6_literal(self):
+        db = yield redis.Connection("::1", self.port, reconnect=False)
+        self.addCleanup(db.disconnect)
+
+        role = yield db.role()
+        self.assertEqual(role[0], "master")

txredisapi-1.6.0/tests/test_reconnect.py

@@ -0,0 +1,244 @@
+# coding: utf-8
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from twisted.internet import defer, error, reactor, task
+from twisted.internet.endpoints import HostnameEndpoint
+from twisted.internet.interfaces import IStreamClientEndpoint
+from twisted.internet.protocol import Factory
+from twisted.trial import unittest
+from zope.interface import implementer
+
+import txredisapi as redis
+
+from tests.test_sentinel import TrackingRedisFactory
+
+
+@implementer(IStreamClientEndpoint)
+class FailingEndpoint(object):
+    """
+    Endpoint that fails synchronously, the way UNIXClientEndpoint does when
+    the socket does not exist.
+    """
+
+    def __init__(self):
+        self.attempts = 0
+
+    def connect(self, protocolFactory):
+        self.attempts += 1
+        return defer.fail(error.ConnectionRefusedError())
+
+
+@implementer(IStreamClientEndpoint)
+class GatedEndpoint(object):
+    """
+    Endpoint that lets the first connection through and refuses the ones
+    after it, but not before the given gate fires.
+    """
+
+    def __init__(self, endpoint, gate):
+        self.endpoint = endpoint
+        self.gate = gate
+        self.attempts = 0
+
+    def connect(self, protocolFactory):
+        self.attempts += 1
+        if self.attempts == 1:
+            return self.endpoint.connect(protocolFactory)
+
+        refused = defer.Deferred()
+        self.gate.addCallback(
+            lambda _: refused.errback(error.ConnectionRefusedError()))
+        return refused
+
+
+class TestReconnect(unittest.TestCase):
+    timeout = 30
+
+    def setUp(self):
+        self.server = TrackingRedisFactory()
+        self.listener = reactor.listenTCP(0, self.server,
+                                          interface="127.0.0.1")
+        self.port = self.listener.getHost().port
+        self.addCleanup(self.listener.stopListening)
+
+    def endpoint(self):
+        return HostnameEndpoint(reactor, "127.0.0.1", self.port)
+
+    @defer.inlineCallbacks
+    def waitFor(self, predicate, message):
+        deadline = reactor.seconds() + 15
+        while not predicate():
+            if reactor.seconds() > deadline:
+                self.fail(message)
+            yield task.deferLater(reactor, 0.05, lambda: None)
+
+    @defer.inlineCallbacks
+    def closedPort(self):
+        listener = reactor.listenTCP(0, Factory(), interface="127.0.0.1")
+        port = listener.getHost().port
+        yield listener.stopListening()
+        return port
+
+    @defer.inlineCallbacks
+    def test_reconnects(self):
+        db = yield redis.Connection("127.0.0.1", self.port)
+        self.addCleanup(db.disconnect)
+        yield db.role()
+
+        self.server.protocols[0].transport.loseConnection()
+
+        yield self.waitFor(lambda: len(self.server.protocols) > 1,
+                           "connection has not been reestablished")
+        role = yield db.role()
+        self.assertEqual(role[0], "master")
+
+    @defer.inlineCallbacks
+    def test_does_not_reconnect_when_disabled(self):
+        # short enough for the wait below to cover several attempts
+        self.patch(redis.RedisFactory, "initialDelay", 0.05)
+
+        db = yield redis.Connection("127.0.0.1", self.port, reconnect=False)
+        self.addCleanup(db.disconnect)
+        yield db.role()
+
+        self.server.protocols[0].transport.loseConnection()
+        yield self.waitFor(lambda: db._factory.size == 0,
+                           "connection has not been dropped")
+
+        # give a reconnect a chance to happen, it should not
+        yield task.deferLater(reactor, 0.3, lambda: None)
+        self.assertEqual(len(self.server.protocols), 1)
+
+        yield self.assertFailure(db.role(), redis.ConnectionError)
+
+    @defer.inlineCallbacks
+    def test_failed_connection_is_reported(self):
+        port = yield self.closedPort()
+        yield self.assertFailure(
+            redis.Connection("127.0.0.1", port, reconnect=False), ValueError)
+
+    @defer.inlineCallbacks
+    def test_first_failure_is_final(self):
+        # long enough for a second attempt to be noticed as a hang
+        self.patch(redis.RedisFactory, "initialDelay", 30)
+
+        endpoint = FailingEndpoint()
+        factory = redis.RedisFactory(None, dbid=None, poolsize=1)
+        factory.reconnect = False
+        deferred = factory.deferred
+        factory.startConnecting(endpoint)
+
+        yield self.assertFailure(deferred, ValueError)
+        self.assertEqual(endpoint.attempts, 1)
+
+    @defer.inlineCallbacks
+    def test_failed_pool_startup_closes_connections(self):
+        gate = defer.Deferred()
+        endpoint = GatedEndpoint(self.endpoint(), gate)
+
+        factory = redis.RedisFactory(None, dbid=None, poolsize=2)
+        factory.reconnect = False
+        deferred = factory.deferred
+        factory.startConnecting(endpoint)
+
+        yield self.waitFor(lambda: factory.size == 1,
+                           "the first connection has not been established")
+        gate.callback(None)
+
+        yield self.assertFailure(deferred, ValueError)
+
+        # the caller got an error instead of the handler, so it can't close
+        # the connection that did come up - we have to
+        yield self.waitFor(lambda: not self.server.protocols[0].connected,
+                           "the established connection has not been closed")
+
+    @defer.inlineCallbacks
+    def test_failed_lazy_pool_keeps_working_connections(self):
+        gate = defer.Deferred()
+        endpoint = GatedEndpoint(self.endpoint(), gate)
+
+        factory = redis.RedisFactory(None, dbid=None, poolsize=2, isLazy=True)
+        factory.reconnect = False
+        # nobody consumes the Deferred of a lazy factory
+        factory.deferred.addErrback(lambda failure: None)
+        factory.startConnecting(endpoint)
+
+        yield self.waitFor(lambda: factory.size == 1,
+                           "the first connection has not been established")
+        gate.callback(None)
+        yield task.deferLater(reactor, 0.3, lambda: None)
+
+        # the handler is in the caller's hands already, so the connection that
+        # did come up stays usable
+        self.assertEqual(factory.size, 1)
+        role = yield factory.handler.role()
+        self.assertEqual(role[0], "master")
+
+        yield factory.handler.disconnect()
+
+    @defer.inlineCallbacks
+    def test_disconnect_cancels_reconnection(self):
+        # long enough for the reconnection to still be scheduled below
+        self.patch(redis.RedisFactory, "initialDelay", 0.5)
+
+        db = yield redis.Connection("127.0.0.1", self.port)
+        yield db.role()
+
+        self.server.protocols[0].transport.loseConnection()
+        yield self.waitFor(lambda: db._factory.size == 0,
+                           "connection has not been dropped")
+
+        # a scheduled reconnection attempt must not survive disconnect()
+        yield db.disconnect()
+        yield task.deferLater(reactor, 1, lambda: None)
+        self.assertEqual(len(self.server.protocols), 1)
+
+    @defer.inlineCallbacks
+    def test_stop_trying_from_connection_made(self):
+        # the pattern examples/subscriber.py shows: give up on the connection
+        # from inside connectionMade, while the endpoint is still finishing
+        # it. Neither hook chains to the base protocol, the way protocols
+        # written for a SubscriberFactory usually don't
+        class StoppingProtocol(redis.RedisProtocol):
+            def connectionMade(self):
+                self.factory.stopTrying()
+                self.transport.loseConnection()
+
+            def connectionLost(self, reason):
+                pass
+
+        factory = redis.RedisFactory(None, dbid=None, poolsize=1)
+        factory.protocol = StoppingProtocol
+        factory.startConnecting(self.endpoint())
+
+        yield self.waitFor(lambda: self.server.protocols and
+                           not self.server.protocols[0].connected,
+                           "the connection has not been closed")
+
+        yield task.deferLater(reactor, 0.3, lambda: None)
+        self.assertEqual(len(self.server.protocols), 1)
+
+    def test_dead_connection_is_not_pooled(self):
+        factory = redis.RedisFactory(None, dbid=None, poolsize=1)
+        conn = factory.buildProtocol(None)
+        # died during the reactor turn addConnection is delayed by
+        conn.connected = 0
+
+        factory.addConnection(conn)
+        self.assertEqual(factory.size, 0)
+
+    def test_retry_delay_does_not_overflow(self):
+        factory = redis.RedisFactory(None, dbid=None, poolsize=1)
+        # a long outage keeps increasing the attempt number
+        self.assertLess(factory.retryDelay(10 ** 6), factory.maxDelay * 2)

{txredisapi-1.5.0 → txredisapi-1.6.0}/tests/test_sentinel.py

@@ -1,5 +1,5 @@
 import sys
-from twisted.internet import defer, reactor
+from twisted.internet import defer, reactor, task
 from twisted.internet.protocol import Factory
 from twisted.trial.unittest import TestCase
 
@@ -106,6 +106,18 @@ class FakeRedisFactory(Factory):
     role = ["master", 0, ["127.0.0.1", 63791, 0]]
 
 
+class TrackingRedisFactory(FakeRedisFactory):
+    """Fake server that keeps every protocol it has built."""
+
+    def __init__(self):
+        self.protocols = []
+
+    def buildProtocol(self, addr):
+        protocol = FakeRedisFactory.buildProtocol(self, addr)
+        self.protocols.append(protocol)
+        return protocol
+
+
 class FakeAuthenticatedRedisFactory(FakeRedisFactory):
     def __init__(self, requirepass):
         self.requirepass = requirepass
@@ -297,6 +309,19 @@ class TestConnectViaSentinel(TestCase):
         reactor.callLater(secs, d.callback, None)
         return d
 
+    @defer.inlineCallbacks
+    def _waitFor(self, predicate, message):
+        deadline = reactor.seconds() + 5
+        while not predicate():
+            if reactor.seconds() > deadline:
+                self.fail(message)
+            yield self._delay(0.02)
+
+    def _pool_is_at(self, conn, port):
+        pool = conn._factory.pool
+        return len(pool) == 3 and all(p.transport.getPeer().port == port
+                                      for p in pool)
+
     @defer.inlineCallbacks
     def test_drop_all_when_master_changes(self):
         # When master address change detected, factory should drop and reestablish
@@ -304,10 +329,8 @@ class TestConnectViaSentinel(TestCase):
 
         conn = self.client.master_for("test", poolsize=3)
         yield conn.role()  # wait for connection
-
-        addrs = [proto.transport.getPeer() for proto in conn._factory.pool]
-        self.assertTrue(len(addrs), 3)
-        self.assertTrue(all(addr.port == self.master_port for addr in addrs))
+        yield self._waitFor(lambda: self._pool_is_at(conn, self.master_port),
+                            "the pool has not been filled from the master")
 
         # Change master address at sentinel and change role of the slave to master
         self.fake_sentinel.master_addr = ("127.0.0.1", self.slave_port)
@@ -316,11 +339,9 @@ class TestConnectViaSentinel(TestCase):
         # Force reconnection of one connection
         conn._factory.pool[0].transport.loseConnection()
 
-        # After a short time all connections should be to the new master
-        yield self._delay(0.2)
-        addrs = [proto.transport.getPeer() for proto in conn._factory.pool]
-        self.assertTrue(len(addrs), 3)
-        self.assertTrue(all(addr.port == self.slave_port for addr in addrs))
+        # All of the connections should end up at the new master
+        yield self._waitFor(lambda: self._pool_is_at(conn, self.slave_port),
+                            "the connections have not moved to the new master")
 
         yield conn.disconnect()
 
@@ -355,3 +376,44 @@ class TestAuthViaSentinel(TestCase):
         reply = yield conn.role()
         self.assertEqual(reply[0], "master")
         yield conn.disconnect()
+
+
+class TestSentinelRetries(TestCase):
+
+    master_port = 36379
+    sentinel_port = 46379
+
+    def setUp(self):
+        self.fake_master = TrackingRedisFactory()
+        self.fake_master.role = ["slave", "127.0.0.1", 63790, "connected", 0]
+        self.master_listener = reactor.listenTCP(self.master_port,
+                                                 self.fake_master)
+
+        self.fake_sentinel = FakeSentinelFactory()
+        self.fake_sentinel.master_addr = ("127.0.0.1", self.master_port)
+        self.fake_sentinel.slave_addrs = []
+        self.fake_sentinel.slave_flags = []
+        self.sentinel_listener = reactor.listenTCP(self.sentinel_port,
+                                                   self.fake_sentinel)
+
+        self.client = Sentinel([("127.0.0.1", self.sentinel_port)])
+        self.client.discovery_timeout = 1
+
+    @defer.inlineCallbacks
+    def tearDown(self):
+        yield self.client.disconnect()
+        yield self.sentinel_listener.stopListening()
+        yield self.master_listener.stopListening()
+
+    @defer.inlineCallbacks
+    def test_wrong_role_backs_off(self):
+        # A node that never has the role we are looking for is dropped by
+        # SentinelRedisProtocol as soon as it replies to ROLE. Such a
+        # connection must not reset the backoff, or we would reconnect to it
+        # in a tight loop
+        conn = self.client.master_for("test")
+
+        yield task.deferLater(reactor, 0.5, lambda: None)
+        self.assertLess(len(self.fake_master.protocols), 5)
+
+        yield conn.disconnect()

txredisapi-1.6.0/tests/test_ssl.py

@@ -0,0 +1,101 @@
+# coding: utf-8
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import datetime
+
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.x509.oid import NameOID
+from OpenSSL import crypto
+from twisted.internet import defer, reactor, ssl
+from twisted.trial import unittest
+
+import txredisapi as redis
+
+from tests.test_sentinel import FakeRedisFactory
+
+
+_options = []
+
+
+def selfSignedOptions():
+    """
+    Server side TLS options with a self-signed certificate, built once because
+    generating a key is slow.
+
+    twisted.internet.ssl.KeyPair.selfSignedCert() would be shorter, but it
+    needs OpenSSL.crypto.X509Req, which recent pyOpenSSL releases no longer
+    have.
+    """
+    if not _options:
+        key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+        name = x509.Name(
+            [x509.NameAttribute(NameOID.COMMON_NAME, u"localhost")])
+        now = datetime.datetime.now(datetime.timezone.utc)
+        certificate = (
+            x509.CertificateBuilder()
+            .subject_name(name)
+            .issuer_name(name)
+            .public_key(key.public_key())
+            .serial_number(1)
+            .not_valid_before(now - datetime.timedelta(days=1))
+            .not_valid_after(now + datetime.timedelta(days=1))
+            .sign(key, hashes.SHA256())
+        )
+        _options.append(ssl.CertificateOptions(
+            privateKey=crypto.PKey.from_cryptography_key(key),
+            certificate=crypto.X509.from_cryptography(certificate)))
+
+    return _options[0]
+
+
+class TestSSLConnections(unittest.TestCase):
+    timeout = 15
+
+    def setUp(self):
+        self.listener = reactor.listenSSL(0, FakeRedisFactory(),
+                                          selfSignedOptions(),
+                                          interface="127.0.0.1")
+        self.port = self.listener.getHost().port
+        self.addCleanup(self.listener.stopListening)
+
+    @defer.inlineCallbacks
+    def test_context_factory(self):
+        db = yield redis.Connection(
+            "127.0.0.1", self.port, reconnect=False,
+            ssl_context_factory=ssl.ClientContextFactory())
+        self.addCleanup(db.disconnect)
+
+        role = yield db.role()
+        self.assertEqual(role[0], "master")
+
+    @defer.inlineCallbacks
+    def test_ssl_true(self):
+        db = yield redis.Connection("127.0.0.1", self.port, reconnect=False,
+                                    ssl_context_factory=True)
+        self.addCleanup(db.disconnect)
+
+        role = yield db.role()
+        self.assertEqual(role[0], "master")
+
+    @defer.inlineCallbacks
+    def test_pool(self):
+        db = yield redis.ConnectionPool("127.0.0.1", self.port, poolsize=2,
+                                        reconnect=False,
+                                        ssl_context_factory=True)
+        self.addCleanup(db.disconnect)
+
+        role = yield db.role()
+        self.assertEqual(role[0], "master")

{txredisapi-1.5.0 → txredisapi-1.6.0}/tests/test_subscriber.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from twisted.internet import defer, reactor
+from twisted.internet.endpoints import HostnameEndpoint
 from twisted.trial import unittest
 
 import txredisapi as redis
@@ -24,8 +25,9 @@ class TestSubscriberProtocol(unittest.TestCase):
     @defer.inlineCallbacks
     def setUp(self):
         factory = redis.SubscriberFactory()
-        factory.continueTrying = False
-        reactor.connectTCP(REDIS_HOST, REDIS_PORT, factory)
+        factory.reconnect = False
+        factory.startConnecting(
+            HostnameEndpoint(reactor, REDIS_HOST, REDIS_PORT))
         self.db = yield factory.deferred
 
     @defer.inlineCallbacks
@@ -125,8 +127,9 @@ class TestAuthenticatedSubscriberProtocol(unittest.TestCase):
         factory = redis.RedisFactory(None, dbid=0, poolsize=1,
                                      password="password")
         factory.protocol = redis.SubscriberProtocol
-        factory.continueTrying = False
-        reactor.connectTCP(REDIS_HOST, REDIS_PORT, factory)
+        factory.reconnect = False
+        factory.startConnecting(
+            HostnameEndpoint(reactor, REDIS_HOST, REDIS_PORT))
         self.db = yield factory.deferred
 
     @defer.inlineCallbacks

{txredisapi-1.5.0 → txredisapi-1.6.0/txredisapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: txredisapi
-Version: 1.5.0
+Version: 1.6.0
 Summary: non-blocking redis client for python
 Home-page: http://github.com/IlyaSkriblovsky/txredisapi
 Author: Alexandre Fiori
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.5
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: twisted[tls]
+Requires-Dist: twisted[tls]>=18.7.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{txredisapi-1.5.0 → txredisapi-1.6.0}/txredisapi.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ tests/test_connection_charset.py
 tests/test_hash_ops.py
 tests/test_hyperloglog.py
 tests/test_implicit_pipelining.py
+tests/test_ipv6.py
 tests/test_list_ops.py
 tests/test_multibulk.py
 tests/test_number_conversions.py
@@ -22,12 +23,14 @@ tests/test_operations.py
 tests/test_pipelining.py
 tests/test_protocol.py
 tests/test_publish.py
+tests/test_reconnect.py
 tests/test_scan.py
 tests/test_scripting.py
 tests/test_sentinel.py
 tests/test_sets.py
 tests/test_sort.py
 tests/test_sortedsets.py
+tests/test_ssl.py
 tests/test_subscriber.py
 tests/test_transactions.py
 tests/test_unix_connection.py

txredisapi-1.6.0/txredisapi.egg-info/requires.txt

@@ -0,0 +1 @@
+twisted[tls]>=18.7.0