bumps version, cleans up deprecations warnings for tests, add pypy to…

… travis targets

.gitignore

@@ -44,3 +44,4 @@ nosetests.xml
 # Intellij Idea
 /.idea/workspace.xml
 
+.python-version

.travis.yml

@@ -1,6 +1,12 @@
 language: python                
 matrix:
   include:
+    - os: linux
+      sudo: required
+      python: pypy
+    - os: linux
+      sudo: required
+      python: "pypy3.5-6.0.0"
     - os: linux
       sudo: required
       python: 2.7
@@ -10,6 +16,9 @@ matrix:
     - os: linux
       sudo: required
       python: 3.6
+    - os: linux
+      sudo: required
+      python: 3.7
 install:
   - pip install .
 script: make test

MANIFEST.in

@@ -1,2 +1,7 @@
 include prestans/devel/gen/templates/closure/filter/*
-include prestans/devel/gen/templates/closure/model/*
+include prestans/devel/gen/templates/closure/model/*
+
+recursive-exclude * __pycache__
+recursive-exclude * *.pyc
+recursive-exclude * *.pyo
+recursive-exclude tests/*

prestans/__init__.py

@@ -33,5 +33,5 @@
 
 __all__ = ['http', 'types', 'rest', 'parser', 'serializer', 'deserializer', 'provider', 'ext', 'exception']
 
-__version_info__ = (2, 3, 1)
+__version_info__ = (2, 3, 2)
 __version__ = '.'.join(str(v) for v in __version_info__)

prestans/ext/data/adapters/sqlalchemy.py

@@ -53,7 +53,7 @@ class ModelAdapter(adapters.ModelAdapter):
     def __init__(self, rest_model_class, persistent_model_class):
         import logging
         logger = logging.getLogger("prestans")
-        logger.warn("direct use of %s has been deprecated please use %s instead" % (
+        logger.warning("direct use of %s has been deprecated please use %s instead" % (
             self.__module__ + "." + self.__class__.__name__,
             adapters.ModelAdapter.__module__ + "." + adapters.ModelAdapter.__name__
         ))

prestans/rest/request.py

@@ -125,7 +125,7 @@ def body_template(self, value):
             raise AssertionError("body_template cannot be set for GET requests")
 
         if value is None:
-            self.logger.warn("body_template is None, parsing will be ignored")
+            self.logger.warning("body_template is None, parsing will be ignored")
             return
 
         if not isinstance(value, DataCollection):

setup.py

@@ -66,8 +66,7 @@
     maintainer_email='support@anomaly.net.au',
     platforms=['any'],
     entry_points={'console_scripts': ['pride = prestans.bin.pride:main']},
-    # scripts=['prestans/bin/pride'],
-    packages=find_packages(),
+    # packages=find_packages(include=['prestans'], exclude=["tests"]),
     classifiers=[
         'Environment :: Web Environment',
         'Intended Audience :: Developers',
@@ -84,6 +83,7 @@
         'jinja2',
         'pytest',
         'pytest-cov',
+        'pytest-runner',
         'mock',
         'tox',
         'tox-pyenv',

tests/devel/gen/closure/test_base.py

@@ -16,11 +16,11 @@ def test_init(self):
             output_directory="namespace/models"
         )
         self.assertIsNone(base._template_engine)
-        self.assertEquals(base._model_file, "models.py")
-        self.assertEquals(base._namespace, "namespace.models")
-        self.assertEquals(base._output_directory, "namespace/models")
-        self.assertEquals(base._dependencies, [])
-        self.assertEquals(base.attribute_string, "")
+        self.assertEqual(base._model_file, "models.py")
+        self.assertEqual(base._namespace, "namespace.models")
+        self.assertEqual(base._output_directory, "namespace/models")
+        self.assertEqual(base._dependencies, [])
+        self.assertEqual(base.attribute_string, "")
 
     def test_add_filter_dependency(self):
         base = Base(
@@ -29,7 +29,7 @@ def test_add_filter_dependency(self):
             namespace="namespace.filters",
             output_directory="namespace/filters"
         )
-        self.assertEquals(base._dependencies, [])
+        self.assertEqual(base._dependencies, [])
 
         class User(types.Model):
             first_name = types.String()
@@ -38,13 +38,13 @@ class User(types.Model):
         user_blueprint["map_name"] = "a"
 
         base.add_filter_dependency(AttributeMetaData("user", user_blueprint))
-        self.assertEquals(base._dependencies, ["namespace.filters.User"])
+        self.assertEqual(base._dependencies, ["namespace.filters.User"])
 
         users_blueprint = types.Array(element_template=User()).blueprint()
         users_blueprint["map_name"] = "b"
 
         base.add_filter_dependency(AttributeMetaData("users", users_blueprint))
-        self.assertEquals(base._dependencies, ["namespace.filters.User"])
+        self.assertEqual(base._dependencies, ["namespace.filters.User"])
 
         class Log(types.Model):
             message = types.String()
@@ -53,7 +53,7 @@ class Log(types.Model):
         logs_blueprint["map_name"] = "c"
 
         base.add_filter_dependency(AttributeMetaData("logs", logs_blueprint))
-        self.assertEquals(base._dependencies, ["namespace.filters.User", "namespace.filters.Log"])
+        self.assertEqual(base._dependencies, ["namespace.filters.User", "namespace.filters.Log"])
 
     def test_add_model_dependency(self):
         base = Base(
@@ -62,7 +62,7 @@ def test_add_model_dependency(self):
             namespace="namespace.models",
             output_directory="namespace/models"
         )
-        self.assertEquals(base._dependencies, [])
+        self.assertEqual(base._dependencies, [])
 
         class User(types.Model):
             first_name = types.String()
@@ -71,31 +71,31 @@ class User(types.Model):
         model_blueprint["map_name"] = "a"
 
         base.add_model_dependency(AttributeMetaData("user", model_blueprint))
-        self.assertEquals(base._dependencies, ["namespace.models.User"])
+        self.assertEqual(base._dependencies, ["namespace.models.User"])
 
         string_blueprint = types.String().blueprint()
         string_blueprint["map_name"] = "a_b"
 
         base.add_model_dependency(AttributeMetaData("first_name", string_blueprint))
-        self.assertEquals(base._dependencies, ["namespace.models.User", "prestans.types.String"])
+        self.assertEqual(base._dependencies, ["namespace.models.User", "prestans.types.String"])
 
         array_basic = types.Array(element_template=types.String()).blueprint()
         array_basic["map_name"] = "c"
 
         base.add_model_dependency(AttributeMetaData("tags", array_basic))
-        self.assertEquals(base._dependencies, ["namespace.models.User", "prestans.types.String"])
+        self.assertEqual(base._dependencies, ["namespace.models.User", "prestans.types.String"])
 
         array_model = types.Array(element_template=User()).blueprint()
         array_model["map_name"] = "d"
 
         base.add_model_dependency(AttributeMetaData("users", array_model))
-        self.assertEquals(base._dependencies, ["namespace.models.User", "prestans.types.String"])
+        self.assertEqual(base._dependencies, ["namespace.models.User", "prestans.types.String"])
 
         integer_blueprint = types.Integer().blueprint()
         integer_blueprint["map_name"] = "e"
 
         base.add_model_dependency(AttributeMetaData("numbers", integer_blueprint))
-        self.assertEquals(
+        self.assertEqual(
             base._dependencies,
             ["namespace.models.User", "prestans.types.String", "prestans.types.Integer"]
         )
@@ -107,13 +107,13 @@ def test_add_attribute_string(self):
             namespace="namespace.models",
             output_directory="namespace/models"
         )
-        self.assertEquals(base.attribute_string, "")
+        self.assertEqual(base.attribute_string, "")
 
         string_blueprint = types.String().blueprint()
         string_blueprint["map_name"] = "a"
 
         base.add_attribute_string(AttributeMetaData("string", string_blueprint))
-        self.assertEquals(base.attribute_string, "this.string_")
+        self.assertEqual(base.attribute_string, "this.string_")
 
         class MyModel(types.Model):
             field = types.String()
@@ -122,13 +122,13 @@ class MyModel(types.Model):
         model_blueprint["map_name"] = "b"
 
         base.add_attribute_string(AttributeMetaData("model", model_blueprint))
-        self.assertEquals(base.attribute_string, "this.string_ || this.model_.anyFieldsEnabled()")
+        self.assertEqual(base.attribute_string, "this.string_ || this.model_.anyFieldsEnabled()")
 
         array_blueprint = types.Array(element_template=MyModel()).blueprint()
         array_blueprint["map_name"] = "c"
 
         base.add_attribute_string(AttributeMetaData("array", array_blueprint))
-        self.assertEquals(
+        self.assertEqual(
             base.attribute_string,
             "this.string_ || this.model_.anyFieldsEnabled() || this.array_.anyFieldsEnabled()"
         )

tests/devel/gen/closure/test_basic_type_element_template.py

@@ -10,15 +10,15 @@ def test_string_default(self):
         string_type = types.String()
 
         string = BasicTypeElementTemplate(string_type.blueprint())
-        self.assertEquals(string.blueprint_type, "string")
-        self.assertEquals(string.client_class_name, "String")
-        self.assertEquals(string.required, "true")
-        self.assertEquals(string.trim, "true")
-        self.assertEquals(string.default, "null")
-        self.assertEquals(string.min_length, "null")
-        self.assertEquals(string.max_length, "null")
-        self.assertEquals(string.format, "null")
-        self.assertEquals(string.choices, "null")
+        self.assertEqual(string.blueprint_type, "string")
+        self.assertEqual(string.client_class_name, "String")
+        self.assertEqual(string.required, "true")
+        self.assertEqual(string.trim, "true")
+        self.assertEqual(string.default, "null")
+        self.assertEqual(string.min_length, "null")
+        self.assertEqual(string.max_length, "null")
+        self.assertEqual(string.format, "null")
+        self.assertEqual(string.choices, "null")
 
     def test_string_given_values(self):
         string_type = types.String(
@@ -32,27 +32,27 @@ def test_string_given_values(self):
         )
 
         string = BasicTypeElementTemplate(string_type.blueprint())
-        self.assertEquals(string.blueprint_type, "string")
-        self.assertEquals(string.client_class_name, "String")
-        self.assertEquals(string.required, "false")
-        self.assertEquals(string.trim, "false")
-        self.assertEquals(string.default, "\"default\"")
-        self.assertEquals(string.min_length, 1)
-        self.assertEquals(string.max_length, 5)
-        self.assertEquals(string.format, "\"[a-z]{2, 8}\"")
-        self.assertEquals(string.choices, ["a", "b", "c"])
+        self.assertEqual(string.blueprint_type, "string")
+        self.assertEqual(string.client_class_name, "String")
+        self.assertEqual(string.required, "false")
+        self.assertEqual(string.trim, "false")
+        self.assertEqual(string.default, "\"default\"")
+        self.assertEqual(string.min_length, 1)
+        self.assertEqual(string.max_length, 5)
+        self.assertEqual(string.format, "\"[a-z]{2, 8}\"")
+        self.assertEqual(string.choices, ["a", "b", "c"])
 
     def test_integer_default(self):
         integer_type = types.Integer()
 
         integer = BasicTypeElementTemplate(integer_type.blueprint())
-        self.assertEquals(integer.blueprint_type, "integer")
-        self.assertEquals(integer.client_class_name, "Integer")
-        self.assertEquals(integer.required, "true")
-        self.assertEquals(integer.default, "null")
-        self.assertEquals(integer.minimum, "null")
-        self.assertEquals(integer.maximum, "null")
-        self.assertEquals(integer.choices, "null")
+        self.assertEqual(integer.blueprint_type, "integer")
+        self.assertEqual(integer.client_class_name, "Integer")
+        self.assertEqual(integer.required, "true")
+        self.assertEqual(integer.default, "null")
+        self.assertEqual(integer.minimum, "null")
+        self.assertEqual(integer.maximum, "null")
+        self.assertEqual(integer.choices, "null")
 
     def test_integer_given_values(self):
         integer_type = types.Integer(
@@ -64,25 +64,25 @@ def test_integer_given_values(self):
         )
 
         integer = BasicTypeElementTemplate(integer_type.blueprint())
-        self.assertEquals(integer.blueprint_type, "integer")
-        self.assertEquals(integer.client_class_name, "Integer")
-        self.assertEquals(integer.required, "false")
-        self.assertEquals(integer.default, 3)
-        self.assertEquals(integer.minimum, 1)
-        self.assertEquals(integer.maximum, 5)
-        self.assertEquals(integer.choices, [1, 3, 5])
+        self.assertEqual(integer.blueprint_type, "integer")
+        self.assertEqual(integer.client_class_name, "Integer")
+        self.assertEqual(integer.required, "false")
+        self.assertEqual(integer.default, 3)
+        self.assertEqual(integer.minimum, 1)
+        self.assertEqual(integer.maximum, 5)
+        self.assertEqual(integer.choices, [1, 3, 5])
 
     def test_float_default(self):
         float_type = types.Float()
 
         float_basic = BasicTypeElementTemplate(float_type.blueprint())
-        self.assertEquals(float_basic.blueprint_type, "float")
-        self.assertEquals(float_basic.client_class_name, "Float")
-        self.assertEquals(float_basic.required, "true")
-        self.assertEquals(float_basic.default, "null")
-        self.assertEquals(float_basic.minimum, "null")
-        self.assertEquals(float_basic.maximum, "null")
-        self.assertEquals(float_basic.choices, "null")
+        self.assertEqual(float_basic.blueprint_type, "float")
+        self.assertEqual(float_basic.client_class_name, "Float")
+        self.assertEqual(float_basic.required, "true")
+        self.assertEqual(float_basic.default, "null")
+        self.assertEqual(float_basic.minimum, "null")
+        self.assertEqual(float_basic.maximum, "null")
+        self.assertEqual(float_basic.choices, "null")
 
     def test_float_given_values(self):
         float_type = types.Float(
@@ -94,22 +94,22 @@ def test_float_given_values(self):
         )
 
         float_basic = BasicTypeElementTemplate(float_type.blueprint())
-        self.assertEquals(float_basic.blueprint_type, "float")
-        self.assertEquals(float_basic.client_class_name, "Float")
-        self.assertEquals(float_basic.required, "false")
-        self.assertEquals(float_basic.default, 4.56)
-        self.assertEquals(float_basic.minimum, 1.0)
-        self.assertEquals(float_basic.maximum, 5.0)
-        self.assertEquals(float_basic.choices, [1.0, 4.56, 5.0])
+        self.assertEqual(float_basic.blueprint_type, "float")
+        self.assertEqual(float_basic.client_class_name, "Float")
+        self.assertEqual(float_basic.required, "false")
+        self.assertEqual(float_basic.default, 4.56)
+        self.assertEqual(float_basic.minimum, 1.0)
+        self.assertEqual(float_basic.maximum, 5.0)
+        self.assertEqual(float_basic.choices, [1.0, 4.56, 5.0])
 
     def test_boolean_default(self):
         boolean_type = types.Boolean()
 
         string = BasicTypeElementTemplate(boolean_type.blueprint())
-        self.assertEquals(string.blueprint_type, "boolean")
-        self.assertEquals(string.client_class_name, "Boolean")
-        self.assertEquals(string.required, "true")
-        self.assertEquals(string.default, "null")
+        self.assertEqual(string.blueprint_type, "boolean")
+        self.assertEqual(string.client_class_name, "Boolean")
+        self.assertEqual(string.required, "true")
+        self.assertEqual(string.default, "null")
 
     def test_boolean_given_values(self):
         boolean_type = types.Boolean(
@@ -118,18 +118,18 @@ def test_boolean_given_values(self):
         )
 
         string = BasicTypeElementTemplate(boolean_type.blueprint())
-        self.assertEquals(string.blueprint_type, "boolean")
-        self.assertEquals(string.client_class_name, "Boolean")
-        self.assertEquals(string.required, "false")
-        self.assertEquals(string.default, "true")
+        self.assertEqual(string.blueprint_type, "boolean")
+        self.assertEqual(string.client_class_name, "Boolean")
+        self.assertEqual(string.required, "false")
+        self.assertEqual(string.default, "true")
 
         boolean_type = types.Boolean(
             required=False,
             default=False
         )
 
         string = BasicTypeElementTemplate(boolean_type.blueprint())
-        self.assertEquals(string.blueprint_type, "boolean")
-        self.assertEquals(string.client_class_name, "Boolean")
-        self.assertEquals(string.required, "false")
-        self.assertEquals(string.default, "false")
+        self.assertEqual(string.blueprint_type, "boolean")
+        self.assertEqual(string.client_class_name, "Boolean")
+        self.assertEqual(string.required, "false")
+        self.assertEqual(string.default, "false")

tests/devel/gen/closure/test_closure.py

@@ -6,7 +6,7 @@
 class ClosureTest(unittest.TestCase):
 
     def test_udl_to_cc(self):
-        self.assertEquals(udl_to_cc("name"), "Name")
-        self.assertEquals(udl_to_cc("first_name"), "FirstName")
-        self.assertEquals(udl_to_cc("last_name"), "LastName")
-        self.assertEquals(udl_to_cc("last_name_field"), "LastNameField")
+        self.assertEqual(udl_to_cc("name"), "Name")
+        self.assertEqual(udl_to_cc("first_name"), "FirstName")
+        self.assertEqual(udl_to_cc("last_name"), "LastName")
+        self.assertEqual(udl_to_cc("last_name_field"), "LastNameField")