Desupport old Python versions, require 2.7 or 3.5+

Cito · Cito · commit f6bbd69fb709 · 2020-04-19T20:10:57.000+02:00
diff --git a/.travis.yml b/.travis.yml
@@ -5,10 +5,10 @@ language: python
 
 python:
   - "2.7"
-  - "3.4"
   - "3.5"
   - "3.6"
   - "3.7"
+  - "3.8"
 
 install:
   - pip install .
diff --git a/docs/about.txt b/docs/about.txt
@@ -37,6 +37,6 @@ D'Arcy (darcy@druid.net) renamed it to PyGreSQL starting with
 version 2.0 and serves as the "BDFL" of PyGreSQL.
 
 The current version PyGreSQL 5.2 needs PostgreSQL 9.0 to 9.6 or 10 to 12, and
-Python 2.6, 2.7 or 3.3 to 3.8. If you need to support older PostgreSQL versions
-or older Python 2.x versions, you can resort to the PyGreSQL 4.x versions that
+Python 2.7 or 3.5 to 3.8. If you need to support older PostgreSQL versions or
+older Python 2.x versions, you can resort to the PyGreSQL 4.x versions that
 still support them.
diff --git a/docs/announce.rst b/docs/announce.rst
@@ -23,7 +23,7 @@ This version has been built and unit tested on:
  - Ubuntu
  - Windows 7 and 10 with both MinGW and Visual Studio
  - PostgreSQL 9.0 to 9.6 and 10 to 12 (32 and 64bit)
- - Python 2.6, 2.7 and 3.3 to 3.8 (32 and 64bit)
+ - Python 2.7 and 3.5 to 3.8 (32 and 64bit)
 
 | D'Arcy J.M. Cain
 | darcy@PyGreSQL.org
diff --git a/docs/contents/changelog.rst b/docs/contents/changelog.rst
@@ -3,7 +3,7 @@ ChangeLog
 
 Version 5.2 (to be released)
 ----------------------------
-- ...
+- We now Python version 2.7 or 3.5 and newer
 
 
 Version 5.1.2 (2020-04-19)
diff --git a/docs/contents/install.rst b/docs/contents/install.rst
@@ -11,7 +11,7 @@ If you are on Windows, make sure that the directory that contains
 libpq.dll is part of your ``PATH`` environment variable.
 
 The current version of PyGreSQL has been tested with Python versions
-2.6, 2.7 and 3.3 to 3.8, and PostgreSQL versions 9.0 to 9.6 and 10 to 12.
+2.7 and 3.5 to 3.8, and PostgreSQL versions 9.0 to 9.6 and 10 to 12.
 
 PyGreSQL will be installed as three modules, a shared library called
 _pg.so (on Linux) or a DLL called _pg.pyd (on Windows), and two pure
diff --git a/pg.py b/pg.py
@@ -75,8 +75,7 @@
 from datetime import date, time, datetime, timedelta, tzinfo
 from decimal import Decimal
 from math import isnan, isinf
-from collections import namedtuple
-from keyword import iskeyword
+from collections import namedtuple, OrderedDict
 from operator import itemgetter
 from functools import partial
 from re import compile as regex
@@ -179,91 +178,6 @@ def wrapper(arg):
 
 # Auxiliary classes and functions that are independent from a DB connection:
 
-try:
-    from collections import OrderedDict
-except ImportError:  # Python 2.6 or 3.0
-    OrderedDict = dict
-
-
-    class AttrDict(dict):
-        """Simple read-only ordered dictionary for storing attribute names."""
-
-        def __init__(self, *args, **kw):
-            if len(args) > 1 or kw:
-                raise TypeError
-            items = args[0] if args else []
-            if isinstance(items, dict):
-                raise TypeError
-            items = list(items)
-            self._keys = [item[0] for item in items]
-            dict.__init__(self, items)
-            self._read_only = True
-            error = self._read_only_error
-            self.clear = self.update = error
-            self.pop = self.setdefault = self.popitem = error
-
-        def __setitem__(self, key, value):
-            if self._read_only:
-                self._read_only_error()
-            dict.__setitem__(self, key, value)
-
-        def __delitem__(self, key):
-            if self._read_only:
-                self._read_only_error()
-            dict.__delitem__(self, key)
-
-        def __iter__(self):
-            return iter(self._keys)
-
-        def keys(self):
-            return list(self._keys)
-
-        def values(self):
-            return [self[key] for key in self]
-
-        def items(self):
-            return [(key, self[key]) for key in self]
-
-        def iterkeys(self):
-            return self.__iter__()
-
-        def itervalues(self):
-            return iter(self.values())
-
-        def iteritems(self):
-            return iter(self.items())
-
-        @staticmethod
-        def _read_only_error(*args, **kw):
-            raise TypeError('This object is read-only')
-
-else:
-
-     class AttrDict(OrderedDict):
-        """Simple read-only ordered dictionary for storing attribute names."""
-
-        def __init__(self, *args, **kw):
-            self._read_only = False
-            OrderedDict.__init__(self, *args, **kw)
-            self._read_only = True
-            error = self._read_only_error
-            self.clear = self.update = error
-            self.pop = self.setdefault = self.popitem = error
-
-        def __setitem__(self, key, value):
-            if self._read_only:
-                self._read_only_error()
-            OrderedDict.__setitem__(self, key, value)
-
-        def __delitem__(self, key):
-            if self._read_only:
-                self._read_only_error()
-            OrderedDict.__delitem__(self, key)
-
-        @staticmethod
-        def _read_only_error(*args, **kw):
-            raise TypeError('This object is read-only')
-
 try:
     from inspect import signature
 except ImportError:  # Python < 3.3
@@ -356,8 +270,8 @@ def __init__(self):
                 self[key] = typ
                 self['_%s' % key] = '%s[]' % typ
 
-    # this could be a static method in Python > 2.6
-    def __missing__(self, key):
+    @staticmethod
+    def __missing__(key):
         return 'text'
 
 _simpletypes = _SimpleTypes()
@@ -428,6 +342,32 @@ class Literal(str):
     """Wrapper class for marking literal SQL values."""
 
 
+class AttrDict(OrderedDict):
+    """Simple read-only ordered dictionary for storing attribute names."""
+
+    def __init__(self, *args, **kw):
+        self._read_only = False
+        OrderedDict.__init__(self, *args, **kw)
+        self._read_only = True
+        error = self._read_only_error
+        self.clear = self.update = error
+        self.pop = self.setdefault = self.popitem = error
+
+    def __setitem__(self, key, value):
+        if self._read_only:
+            self._read_only_error()
+        OrderedDict.__setitem__(self, key, value)
+
+    def __delitem__(self, key):
+        if self._read_only:
+            self._read_only_error()
+        OrderedDict.__delitem__(self, key)
+
+    @staticmethod
+    def _read_only_error(*args, **kw):
+        raise TypeError('This object is read-only')
+
+
 class Adapter:
     """Class providing methods for adapting parameters to the database."""
 
@@ -1328,13 +1268,7 @@ def typecast(self, value, typ):
 def _row_factory(names):
     """Get a namedtuple factory for row results with the given names."""
     try:
-        try:
-            return namedtuple('Row', names, rename=True)._make
-        except TypeError:  # Python 2.6 and 3.0 do not support rename
-            names = [v if _re_fieldname.match(v) and not iskeyword(v)
-                        else 'column_%d' % (n,)
-                     for n, v in enumerate(names)]
-            return namedtuple('Row', names)._make
+        return namedtuple('Row', names, rename=True)._make
     except ValueError:  # there is still a problem with the field names
         names = ['column_%d' % (n,) for n in range(len(names))]
         return namedtuple('Row', names)._make
diff --git a/pgdb.py b/pgdb.py
@@ -112,7 +112,6 @@
 except ImportError:  # Python < 3.3
     from collections import Iterable
 from collections import namedtuple
-from keyword import iskeyword
 from functools import partial
 from re import compile as regex
 from json import loads as jsondecode, dumps as jsonencode
@@ -867,13 +866,7 @@ def _op_error(msg):
 def _row_factory(names):
     """Get a namedtuple factory for row results with the given names."""
     try:
-        try:
-            return namedtuple('Row', names, rename=True)._make
-        except TypeError:  # Python 2.6 and 3.0 do not support rename
-            names = [v if _re_fieldname.match(v) and not iskeyword(v)
-                        else 'column_%d' % (n,)
-                     for n, v in enumerate(names)]
-            return namedtuple('Row', names)._make
+        return namedtuple('Row', names, rename=True)._make
     except ValueError:  # there is still a problem with the field names
         names = ['column_%d' % (n,) for n in range(len(names))]
         return namedtuple('Row', names)._make
diff --git a/setup.py b/setup.py
@@ -26,7 +26,7 @@
 * PostgreSQL pg_config tool (usually included in the devel package)
   (the Windows installer has it as part of the database server feature)
 
-PyGreSQL currently supports Python versions 2.6, 2.7 and 3.3 to 3.8,
+PyGreSQL currently supports Python versions 2.7 and 3.5 to 3.8,
 and PostgreSQL versions 9.0 to 9.6 and 10 to 12.
 
 Use as follows:
@@ -232,11 +232,8 @@ def finalize_options(self):
         "Programming Language :: C",
         'Programming Language :: Python',
         'Programming Language :: Python :: 2',
-        'Programming Language :: Python :: 2.6',
         'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.3',
-        'Programming Language :: Python :: 3.4',
         'Programming Language :: Python :: 3.5',
         'Programming Language :: Python :: 3.6',
         'Programming Language :: Python :: 3.7',
diff --git a/tests/test_classic_connection.py b/tests/test_classic_connection.py
@@ -462,12 +462,8 @@ def testNamedresultWithGoodFieldnames(self):
         self.assertEqual(v._fields, ('snake_case_alias', 'CamelCaseAlias'))
 
     def testNamedresultWithBadFieldnames(self):
-        try:
-            r = namedtuple('Bad', ['?'] * 6, rename=True)
-        except TypeError:  # Python 2.6 or 3.0
-            fields = tuple('column_%d' % n for n in range(6))
-        else:
-            fields = r._fields
+        r = namedtuple('Bad', ['?'] * 6, rename=True)
+        fields = r._fields
         q = ('select 3 as "0alias", 4 as _alias, 5 as "alias$", 6 as "alias?",'
             ' 7 as "kebap-case-alias", 8 as break, 9 as and_a_good_one')
         result = [tuple(range(3, 10))]
diff --git a/tests/test_classic_dbwrapper.py b/tests/test_classic_dbwrapper.py
@@ -56,14 +56,11 @@
 except NameError:  # Python >= 3.0
     unicode = str
 
-try:
-    from collections import OrderedDict
-except ImportError:  # Python 2.6 or 3.0
-    OrderedDict = dict
+from collections import OrderedDict
 
 if str is bytes:  # noinspection PyUnresolvedReferences
     from StringIO import StringIO
-else:
+else:  # Python >= 3.0
     from io import StringIO
 
 windows = os.name == 'nt'
@@ -226,11 +223,7 @@ def testAllDBAttributes(self):
             'unescape_bytea', 'update', 'upsert',
             'use_regtypes', 'user',
         ]
-        # __dir__ is not called in Python 2.6 for old-style classes
-        db_attributes = dir(self.db) if hasattr(
-            self.db.__class__, '__class__') else self.db.__dir__()
-        db_attributes = [a for a in db_attributes
-            if not a.startswith('_')]
+        db_attributes = [a for a in self.db.__dir__() if not a.startswith('_')]
         self.assertEqual(attributes, db_attributes)
 
     def testAttributeDb(self):
@@ -1005,11 +998,6 @@ def testQueryFormatted(self):
         # test with tuple, inline
         q = f("select %s, %s, %s, %s", (3, 2.5, 'hello', True), inline=True)
         r = q.getresult()[0]
-        if isinstance(r[1], Decimal):
-            # Python 2.6 cannot compare float and Decimal
-            r = list(r)
-            r[1] = float(r[1])
-            r = tuple(r)
         self.assertEqual(r, (3, 2.5, 'hello', t))
         # test with dict
         q = f("select %(a)s::int, %(b)s::real, %(c)s::text, %(d)s::bool",
@@ -2944,8 +2932,7 @@ def testGetAsDict(self):
                 self.assertEqual(row.rgb, t[0])
                 self.assertEqual(row.name, t[1])
                 self.assertEqual(row._asdict(), dict(rgb=t[0], name=t[1]))
-        if OrderedDict is not dict:  # Python > 2.6
-            self.assertEqual(r.keys(), expected.keys())
+        self.assertEqual(r.keys(), expected.keys())
         r = get_as_dict(table, keyname='rgb')
         self.assertIsInstance(r, OrderedDict)
         expected = OrderedDict((row[1], (row[0], row[2]))
@@ -2962,8 +2949,7 @@ def testGetAsDict(self):
                 self.assertEqual(row.id, t[0])
                 self.assertEqual(row.name, t[1])
                 self.assertEqual(row._asdict(), dict(id=t[0], name=t[1]))
-        if OrderedDict is not dict:  # Python > 2.6
-            self.assertEqual(r.keys(), expected.keys())
+        self.assertEqual(r.keys(), expected.keys())
         r = get_as_dict(table, keyname=['id', 'rgb'])
         self.assertIsInstance(r, OrderedDict)
         expected = OrderedDict((row[:2], row[2:]) for row in colors)
@@ -2983,8 +2969,7 @@ def testGetAsDict(self):
             if named:
                 self.assertEqual(row.name, t[0])
                 self.assertEqual(row._asdict(), dict(name=t[0]))
-        if OrderedDict is not dict:  # Python > 2.6
-            self.assertEqual(r.keys(), expected.keys())
+        self.assertEqual(r.keys(), expected.keys())
         r = get_as_dict(table, keyname=['id', 'rgb'], scalar=True)
         self.assertIsInstance(r, OrderedDict)
         expected = OrderedDict((row[:2], row[2]) for row in colors)
@@ -2995,8 +2980,7 @@ def testGetAsDict(self):
             self.assertIsInstance(row, str)
             t = expected[key]
             self.assertEqual(row, t)
-        if OrderedDict is not dict:  # Python > 2.6
-            self.assertEqual(r.keys(), expected.keys())
+        self.assertEqual(r.keys(), expected.keys())
         r = get_as_dict(table, keyname='rgb', what=['rgb', 'name'], scalar=True)
         self.assertIsInstance(r, OrderedDict)
         expected = OrderedDict((row[1], row[2])
@@ -3008,8 +2992,7 @@ def testGetAsDict(self):
             self.assertIsInstance(row, str)
             t = expected[key]
             self.assertEqual(row, t)
-        if OrderedDict is not dict:  # Python > 2.6
-            self.assertEqual(r.keys(), expected.keys())
+        self.assertEqual(r.keys(), expected.keys())
         r = get_as_dict(table, what='id, name',
             where="rgb like '#b%'", scalar=True)
         self.assertIsInstance(r, OrderedDict)
@@ -3021,8 +3004,7 @@ def testGetAsDict(self):
             self.assertIsInstance(row, str)
             t = expected[key]
             self.assertEqual(row, t)
-        if OrderedDict is not dict:  # Python > 2.6
-            self.assertEqual(r.keys(), expected.keys())
+        self.assertEqual(r.keys(), expected.keys())
         expected = r
         r = get_as_dict(table, what=['name', 'id'],
             where=['id > 1', 'id < 4', "rgb like '#b%'",
@@ -3050,8 +3032,7 @@ def testGetAsDict(self):
         r = get_as_dict(table, order=False)
         self.assertIsInstance(r, dict)
         self.assertEqual(r, expected)
-        if dict is not OrderedDict:  # Python > 2.6
-            self.assertNotIsInstance(self, OrderedDict)
+        self.assertNotIsInstance(self, OrderedDict)
         # test with arbitrary from clause
         from_table = '(select id, lower(name) as n2 from "%s") as t2' % table
         # primary key must be passed explicitly in this case
diff --git a/tests/test_dbapi20.py b/tests/test_dbapi20.py
diff --git a/tox.ini b/tox.ini
