txredisapi 1.4.12__tar.gz → 1.6.0__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: txredisapi
-Version: 1.4.12
+Version: 1.6.0
 Summary: non-blocking redis client for python
 Home-page: http://github.com/IlyaSkriblovsky/txredisapi
 Author: Alexandre Fiori
@@ -11,7 +11,6 @@ Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3.5
 Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
@@ -20,10 +19,21 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.5
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: twisted
-Requires-Dist: six
+Requires-Dist: twisted[tls]>=18.7.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 txredisapi
 ==========

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

@@ -23,9 +23,10 @@ long_description = (this_directory / "README.md").read_text()
 
 setuptools.setup(
     name="txredisapi",
-    version="1.4.12",
+    version="1.6.0",
     py_modules=["txredisapi"],
-    install_requires=["twisted", "six"],
+    install_requires=["twisted[tls]>=18.7.0"],
+    python_requires=">=3.5",
     author="Alexandre Fiori",
     author_email="fiorix@gmail.com",
     url="http://github.com/IlyaSkriblovsky/txredisapi",
@@ -39,7 +40,6 @@ setuptools.setup(
         'Operating System :: OS Independent',
         'License :: OSI Approved :: Apache Software License',
         'Programming Language :: Python',
-        'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: 3.5',
         'Programming Language :: Python :: 3.6',
         'Programming Language :: Python :: 3.7',

{txredisapi-1.4.12 → txredisapi-1.6.0}/tests/test_bitops.py

@@ -13,8 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import six
-
 import sys
 import operator
 
@@ -48,7 +46,7 @@ class TestBitOps(unittest.TestCase, Redis26CheckMixin):
     @defer.inlineCallbacks
     def test_getbit(self):
         key = self._KEYS[0]
-        yield self.db.set(key, six.b('\xaa'))
+        yield self.db.set(key, b'\xaa')
         l = [1, 0, 1, 0, 1, 0, 1, 0]
         for x in range(8):
             r = yield self.db.getbit(key, x)
@@ -86,30 +84,30 @@ class TestBitOps(unittest.TestCase, Redis26CheckMixin):
     def test_bitop_not(self):
         return self._test_bitop([operator.__not__, operator.not_,
                                  'not', 'NOT', 'NoT'],
-                                six.b('\x0f\x0f\x0f\x0f'),
+                                b'\x0f\x0f\x0f\x0f',
                                 None,
-                                six.b('\xf0\xf0\xf0\xf0'))
+                                b'\xf0\xf0\xf0\xf0')
 
     def test_bitop_or(self):
         return self._test_bitop([operator.__or__, operator.or_,
                                  'or', 'OR', 'oR'],
-                                six.b('\x0f\x0f\x0f\x0f'),
-                                six.b('\xf0\xf0\xf0\xf0'),
-                                six.b('\xff\xff\xff\xff'))
+                                b'\x0f\x0f\x0f\x0f',
+                                b'\xf0\xf0\xf0\xf0',
+                                b'\xff\xff\xff\xff')
 
     def test_bitop_and(self):
         return self._test_bitop([operator.__and__, operator.and_,
                                  'and', 'AND', 'AnD'],
-                                six.b('\x0f\x0f\x0f\x0f'),
-                                six.b('\xf0\xf0\xf0\xf0'),
-                                six.b('\x00\x00\x00\x00'))
+                                b'\x0f\x0f\x0f\x0f',
+                                b'\xf0\xf0\xf0\xf0',
+                                b'\x00\x00\x00\x00')
 
     def test_bitop_xor(self):
         return self._test_bitop([operator.__xor__, operator.xor,
                                  'xor', 'XOR', 'XoR'],
-                                six.b('\x9c\x9c\x9c\x9c'),
-                                six.b('\x6c\x6c\x6c\x6c'),
-                                six.b('\xf0\xf0\xf0\xf0'))
+                                b'\x9c\x9c\x9c\x9c',
+                                b'\x6c\x6c\x6c\x6c',
+                                b'\xf0\xf0\xf0\xf0')
 
     def test_bitop_invalid(self):
         self.assertFailure(self.db.bitop('test', 'test', 'test'),

{txredisapi-1.4.12 → txredisapi-1.6.0}/tests/test_connection_charset.py

@@ -13,8 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import six
-
 from twisted.internet import defer
 from twisted.trial import unittest
 
@@ -25,7 +23,7 @@ from tests.mixins import REDIS_HOST, REDIS_PORT
 
 class TestConnectionCharset(unittest.TestCase):
     TEST_KEY = 'txredisapi:test_key'
-    TEST_VALUE_UNICODE = six.text_type('\u262d' * 3)
+    TEST_VALUE_UNICODE = str('\u262d' * 3)
     TEST_VALUE_BINARY = b'\x00\x01' * 3
 
     @defer.inlineCallbacks
@@ -34,7 +32,7 @@ class TestConnectionCharset(unittest.TestCase):
 
         yield db.set(self.TEST_KEY, self.TEST_VALUE_BINARY)
         result = yield db.get(self.TEST_KEY)
-        self.assertTrue(type(result) == six.binary_type)
+        self.assertTrue(type(result) == bytes)
         self.assertEqual(result, self.TEST_VALUE_BINARY)
 
         yield db.delete(self.TEST_KEY)
@@ -47,7 +45,7 @@ class TestConnectionCharset(unittest.TestCase):
         yield db.set(self.TEST_KEY, self.TEST_VALUE_UNICODE)
         result = yield db.get(self.TEST_KEY)
         self.assertEqual(result, self.TEST_VALUE_UNICODE)
-        self.assertTrue(type(result) == six.text_type)
+        self.assertTrue(type(result) == str)
 
         yield db.delete(self.TEST_KEY)
         yield db.disconnect()

{txredisapi-1.4.12 → txredisapi-1.6.0}/tests/test_hash_ops.py

@@ -13,8 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import six
-
 from twisted.internet import defer
 from twisted.trial import unittest
 
@@ -58,8 +56,8 @@ class TestRedisHashOperations(unittest.TestCase):
         t_dict['key2'] = 'dos'
         yield db.hmset("txredisapi:HKeysHVals", t_dict)
 
-        vs_u = [six.text_type(v) for v in t_dict.values()]
-        ks_u = [six.text_type(k) for k in t_dict.keys()]
+        vs_u = [str(v) for v in t_dict.values()]
+        ks_u = [str(k) for k in t_dict.keys()]
         k_res = yield db.hkeys("txredisapi:HKeysHVals")
         v_res = yield db.hvals("txredisapi:HKeysHVals")
         self.assertEqual(sorted(ks_u), sorted(k_res))

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.4.12 → txredisapi-1.6.0}/tests/test_multibulk.py

@@ -13,8 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import six
-
 import os
 import base64
 
@@ -61,7 +59,7 @@ class LargeMultiBulk(unittest.TestCase):
     @defer.inlineCallbacks
     def test_bulk_numeric(self):
         test_values = [
-            six.b(''), six.b('.hello'), six.b('+world'), six.b('123test'),
+            b'', b'.hello', b'+world', b'123test',
             +1, 0.1, 0.01, -0.1, 0, -10]
         for v in test_values:
             yield self.db.set(self._KEY, v)
@@ -76,7 +74,7 @@ class LargeMultiBulk(unittest.TestCase):
         if there's a '.' in the string.
         This test is to ensure this behavior isn't broken in the future.
         '''
-        values = [six.b('+inf'), six.b('-inf'), six.b('NaN')]
+        values = [b'+inf', b'-inf', b'NaN']
         for x in values:
             yield self.db.set(self._KEY, x)
             r = yield self.db.get(self._KEY)

{txredisapi-1.4.12 → txredisapi-1.6.0}/tests/test_number_conversions.py

@@ -13,8 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import six
-
 import txredisapi as redis
 from twisted.internet import defer
 from twisted.trial import unittest
@@ -58,7 +56,7 @@ class TestNumberConversions(unittest.TestCase):
                     expected = format(k, "f")
                 else:
                     expected = str(k)
-                self.assertIsInstance(result, six.string_types)
+                self.assertIsInstance(result, str)
                 self.assertEqual(result, expected)
 
     @defer.inlineCallbacks

{txredisapi-1.4.12 → txredisapi-1.6.0}/tests/test_pipelining.py

@@ -15,8 +15,6 @@
 
 import sys
 
-import six
-
 from twisted.trial import unittest
 from twisted.internet import defer
 from twisted.python import log
@@ -71,8 +69,8 @@ class TestRedisConnections(unittest.TestCase):
 
         # Make sure that all SET commands were sent in a single pipelined write.
         write_history = pipeline.transport.write_history
-        lines_in_first_write = write_history[0].split(six.b("\n"))
-        sets_in_first_write = sum(1 for w in lines_in_first_write if six.b("SET") in w)
+        lines_in_first_write = write_history[0].split(b"\n")
+        sets_in_first_write = sum(1 for w in lines_in_first_write if b"SET" in w)
         self.assertEqual(sets_in_first_write, 3)
 
     @defer.inlineCallbacks

{txredisapi-1.4.12 → txredisapi-1.6.0}/tests/test_protocol.py

@@ -13,8 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import six
-
 import txredisapi as redis
 
 from twisted.trial import unittest
@@ -36,7 +34,7 @@ class LineReceiverSubclass(redis.LineReceiver):
 
 
 class TestLineReciever(unittest.TestCase):
-    S = six.b('TEST')
+    S = b'TEST'
 
     def setUp(self):
         self.proto = LineReceiverSubclass()
@@ -47,14 +45,14 @@ class TestLineReciever(unittest.TestCase):
 
     def test_excess_line_length(self):
         self.assertTrue(self.transport.connected)
-        self.proto.dataReceived(six.b('\x00') * (self.proto.MAX_LENGTH + 1))
+        self.proto.dataReceived(b'\x00' * (self.proto.MAX_LENGTH + 1))
         self.assertFalse(self.transport.connected)
 
     def test_excess_delimited_line(self):
         self.assertTrue(self.transport.connected)
         self.proto.dataReceived(self.S + self.proto.delimiter)
         self.assertEqual(self.proto._rcvd_line, self.S.decode())
-        s = (six.b('\x00') * (self.proto.MAX_LENGTH + 1)) + self.proto.delimiter
+        s = (b'\x00' * (self.proto.MAX_LENGTH + 1)) + self.proto.delimiter
         self.proto._rcvd_line = None
         self.proto.dataReceived(s)
         self.assertFalse(self.transport.connected)
@@ -94,4 +92,4 @@ class TestBaseRedisProtocol(unittest.TestCase):
 
     def test_build_ping(self):
         s = self._protocol._build_command("PING")
-        self.assertEqual(s, six.b('*1\r\n$4\r\nPING\r\n'))
+        self.assertEqual(s, b'*1\r\n$4\r\nPING\r\n')

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.4.12 → txredisapi-1.6.0}/tests/test_scripting.py

@@ -16,8 +16,6 @@
 import sys
 import hashlib
 
-import six
-
 import txredisapi as redis
 
 from twisted.internet import defer