testgres 1.13.5__tar.gz → 1.13.7__tar.gz

{testgres-1.13.5/testgres.egg-info → testgres-1.13.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres
-Version: 1.13.5
+Version: 1.13.7
 Summary: Testing utility for PostgreSQL and its extensions
 Author-email: Postgres Professional <testgres@postgrespro.ru>
 License: PostgreSQL

{testgres-1.13.5 → testgres-1.13.7}/pyproject.toml

@@ -5,6 +5,9 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools.package-dir]
 "testgres" = "src"
 
+[tool.setuptools.dynamic]
+version = {attr = "testgres.__version__"}
+
 [tool.flake8]
 extend-ignore = ["E501"]
 exclude = [".git", "__pycache__", "env", "venv"]
@@ -19,7 +22,7 @@ log_file_date_format = "%Y-%m-%d %H:%M:%S"
 
 [project]
 name = "testgres"
-version = "1.13.5"
+dynamic = ["version"]
 
 description = "Testing utility for PostgreSQL and its extensions"
 readme = "README.md"

{testgres-1.13.5 → testgres-1.13.7}/src/__init__.py

@@ -56,6 +56,8 @@ from testgres.operations.os_ops import OsOperations, ConnectionParams
 from testgres.operations.local_ops import LocalOperations
 from testgres.operations.remote_ops import RemoteOperations
 
+__version__ = "1.13.7"
+
 __all__ = [
     "get_new_node",
     "get_remote_node",

{testgres-1.13.5 → testgres-1.13.7}/src/backup.py

@@ -160,7 +160,7 @@ class NodeBackup(object):
             node = NodeClass(name=name, base_dir=base_dir, conn_params=self.original_node.os_ops.conn_params)
 
         assert node is not None
-        assert type(node) == self.original_node.__class__  # noqa: E721
+        assert type(node) is self.original_node.__class__
 
         with clean_on_error(node) as node:
             # Set a new port

{testgres-1.13.5 → testgres-1.13.7}/src/cache.py

@@ -34,7 +34,7 @@ def cached_initdb(data_dir, logfile=None, params=None, os_ops: OsOperations = No
 
     def make_utility_path(name):
         assert name is not None
-        assert type(name) == str  # noqa: E721
+        assert type(name) is str
 
         if bin_path:
             return os_ops.build_path(bin_path, name)

{testgres-1.13.5 → testgres-1.13.7}/src/exceptions.py

@@ -15,14 +15,14 @@ class PortForException(TestgresException):
         self,
         message: typing.Optional[str] = None,
     ):
-        assert message is None or type(message) == str  # noqa: E721
+        assert message is None or type(message) is str
         super().__init__(message)
         self._message = message
         return
 
     @property
     def message(self) -> str:
-        assert self._message is None or type(self._message) == str  # noqa: E721
+        assert self._message is None or type(self._message) is str
         if self._message is None:
             return ""
         return self._message
@@ -53,8 +53,8 @@ class QueryException(TestgresException):
         message: typing.Optional[str] = None,
         query: typing.Optional[str] = None
     ):
-        assert message is None or type(message) == str  # noqa: E721
-        assert query is None or type(query) == str  # noqa: E721
+        assert message is None or type(message) is str
+        assert query is None or type(query) is str
 
         super().__init__(message)
 
@@ -64,8 +64,8 @@ class QueryException(TestgresException):
 
     @property
     def message(self) -> str:
-        assert self._description is None or type(self._description) == str  # noqa: E721
-        assert self._query is None or type(self._query) == str  # noqa: E721
+        assert self._description is None or type(self._description) is str
+        assert self._query is None or type(self._query) is str
 
         msg = []
 
@@ -76,17 +76,17 @@ class QueryException(TestgresException):
             msg.append(u'Query: {}'.format(self._query))
 
         r = six.text_type('\n').join(msg)
-        assert type(r) == str  # noqa: E721
+        assert type(r) is str
         return r
 
     @property
     def description(self) -> typing.Optional[str]:
-        assert self._description is None or type(self._description) == str  # noqa: E721
+        assert self._description is None or type(self._description) is str
         return self._description
 
     @property
     def query(self) -> typing.Optional[str]:
-        assert self._query is None or type(self._query) == str  # noqa: E721
+        assert self._query is None or type(self._query) is str
         return self._query
 
     def __repr__(self) -> str:
@@ -114,8 +114,8 @@ class QueryTimeoutException(QueryException):
         message: typing.Optional[str] = None,
         query: typing.Optional[str] = None
     ):
-        assert message is None or type(message) == str  # noqa: E721
-        assert query is None or type(query) == str  # noqa: E721
+        assert message is None or type(message) is str
+        assert query is None or type(query) is str
 
         super().__init__(message, query)
         return
@@ -133,14 +133,14 @@ class CatchUpException(TestgresException):
         self,
         message: typing.Optional[str] = None,
     ):
-        assert message is None or type(message) == str  # noqa: E721
+        assert message is None or type(message) is str
         super().__init__(message)
         self._message = message
         return
 
     @property
     def message(self) -> str:
-        assert self._message is None or type(self._message) == str  # noqa: E721
+        assert self._message is None or type(self._message) is str
         if self._message is None:
             return ""
         return self._message
@@ -171,7 +171,7 @@ class StartNodeException(TestgresException):
         message: typing.Optional[str] = None,
         files: typing.Optional[typing.Iterable] = None
     ):
-        assert message is None or type(message) == str  # noqa: E721
+        assert message is None or type(message) is str
         assert files is None or isinstance(files, typing.Iterable)
 
         super().__init__(message)
@@ -182,7 +182,7 @@ class StartNodeException(TestgresException):
 
     @property
     def message(self) -> str:
-        assert self._description is None or type(self._description) == str  # noqa: E721
+        assert self._description is None or type(self._description) is str
         assert self._files is None or isinstance(self._files, typing.Iterable)
 
         msg = []
@@ -191,15 +191,15 @@ class StartNodeException(TestgresException):
             msg.append(self._description)
 
         for f, lines in self._files or []:
-            assert type(f) == str  # noqa: E721
-            assert type(lines) in [str, bytes]  # noqa: E721
+            assert type(f) is str
+            assert type(lines) in [str, bytes]
             msg.append(u'{}\n----\n{}\n'.format(f, lines))
 
         return six.text_type('\n').join(msg)
 
     @property
     def description(self) -> typing.Optional[str]:
-        assert self._description is None or type(self._description) == str  # noqa: E721
+        assert self._description is None or type(self._description) is str
         return self._description
 
     @property
@@ -233,14 +233,14 @@ class InitNodeException(TestgresException):
         self,
         message: typing.Optional[str] = None,
     ):
-        assert message is None or type(message) == str  # noqa: E721
+        assert message is None or type(message) is str
         super().__init__(message)
         self._message = message
         return
 
     @property
     def message(self) -> str:
-        assert self._message is None or type(self._message) == str  # noqa: E721
+        assert self._message is None or type(self._message) is str
         if self._message is None:
             return ""
         return self._message
@@ -268,14 +268,14 @@ class BackupException(TestgresException):
         self,
         message: typing.Optional[str] = None,
     ):
-        assert message is None or type(message) == str  # noqa: E721
+        assert message is None or type(message) is str
         super().__init__(message)
         self._message = message
         return
 
     @property
     def message(self) -> str:
-        assert self._message is None or type(self._message) == str  # noqa: E721
+        assert self._message is None or type(self._message) is str
         if self._message is None:
             return ""
         return self._message

{testgres-1.13.5 → testgres-1.13.7}/src/impl/internal_utils.py

@@ -2,19 +2,19 @@ import logging
 
 
 def send_log(level: int, msg: str) -> None:
-    assert type(level) == int  # noqa: E721
-    assert type(msg) == str  # noqa: E721
+    assert type(level) is int
+    assert type(msg) is str
 
     return logging.log(level, "[testgres] " + msg)
 
 
 def send_log_info(msg: str) -> None:
-    assert type(msg) == str  # noqa: E721
+    assert type(msg) is str
 
     return send_log(logging.INFO, msg)
 
 
 def send_log_debug(msg: str) -> None:
-    assert type(msg) == str  # noqa: E721
+    assert type(msg) is str
 
     return send_log(logging.DEBUG, msg)

{testgres-1.13.5 → testgres-1.13.7}/src/impl/platforms/internal_platform_utils.py

@@ -23,15 +23,15 @@ class InternalPlatformUtils:
             code: InternalPlatformUtils.FindPostmasterResultCode,
             pid: typing.Optional[int]
         ):
-            assert type(code) == InternalPlatformUtils.FindPostmasterResultCode  # noqa: E721
-            assert pid is None or type(pid) == int  # noqa: E721
+            assert type(code) is InternalPlatformUtils.FindPostmasterResultCode
+            assert pid is None or type(pid) is int
             self.code = code
             self.pid = pid
             return
 
         @staticmethod
         def create_ok(pid: int) -> InternalPlatformUtils.FindPostmasterResult:
-            assert type(pid) == int  # noqa: E721
+            assert type(pid) is int
             return __class__(InternalPlatformUtils.FindPostmasterResultCode.ok, pid)
 
         @staticmethod
@@ -57,6 +57,6 @@ class InternalPlatformUtils:
         data_dir: str
     ) -> FindPostmasterResult:
         assert isinstance(os_ops, OsOperations)
-        assert type(bin_dir) == str  # noqa: E721
-        assert type(data_dir) == str  # noqa: E721
+        assert type(bin_dir) is str
+        assert type(data_dir) is str
         raise NotImplementedError("InternalPlatformUtils::FindPostmaster is not implemented.")

{testgres-1.13.5 → testgres-1.13.7}/src/impl/platforms/internal_platform_utils_factory.py

@@ -9,7 +9,7 @@ def create_internal_platform_utils(
     assert isinstance(os_ops, OsOperations)
 
     platform_name = os_ops.get_platform()
-    assert type(platform_name) == str  # noqa: E721
+    assert type(platform_name) is str
 
     if platform_name == "linux":
         from .linux import internal_platform_utils as x

{testgres-1.13.5 → testgres-1.13.7}/src/impl/platforms/linux/internal_platform_utils.py

@@ -26,10 +26,10 @@ class InternalPlatformUtils(base.InternalPlatformUtils):
         data_dir: str
     ) -> InternalPlatformUtils.FindPostmasterResult:
         assert isinstance(os_ops, OsOperations)
-        assert type(bin_dir) == str  # noqa: E721
-        assert type(data_dir) == str  # noqa: E721
-        assert type(__class__.C_BASH_EXE) == str  # noqa: E721
-        assert type(__class__.sm_exec_env) == dict  # noqa: E721
+        assert type(bin_dir) is str
+        assert type(data_dir) is str
+        assert type(__class__.C_BASH_EXE) is str
+        assert type(__class__.sm_exec_env) is dict
         assert len(__class__.C_BASH_EXE) > 0
         assert len(bin_dir) > 0
         assert len(data_dir) > 0
@@ -37,8 +37,8 @@ class InternalPlatformUtils(base.InternalPlatformUtils):
         pg_path_e = re.escape(os_ops.build_path(bin_dir, "postgres"))
         data_dir_e = re.escape(data_dir)
 
-        assert type(pg_path_e) == str  # noqa: E721
-        assert type(data_dir_e) == str  # noqa: E721
+        assert type(pg_path_e) is str
+        assert type(data_dir_e) is str
 
         regexp = r"^\s*[0-9]+\s+" + pg_path_e + r"(\s+.*)?\s+\-[D]\s+" + data_dir_e + r"(\s+.*)?"
 
@@ -55,14 +55,14 @@ class InternalPlatformUtils(base.InternalPlatformUtils):
             exec_env=__class__.sm_exec_env,
         )
 
-        assert type(output_b) == bytes  # noqa: E721
-        assert type(error_b) == bytes  # noqa: E721
+        assert type(output_b) is bytes
+        assert type(error_b) is bytes
 
         output = output_b.decode("utf-8")
         error = error_b.decode("utf-8")
 
-        assert type(output) == str  # noqa: E721
-        assert type(error) == str  # noqa: E721
+        assert type(output) is str
+        assert type(error) is str
 
         if exit_status == 1:
             return __class__.FindPostmasterResult.create_not_found()
@@ -78,7 +78,7 @@ class InternalPlatformUtils(base.InternalPlatformUtils):
             )
 
         lines = output.splitlines()
-        assert type(lines) == list  # noqa: E721
+        assert type(lines) is list
 
         if len(lines) == 0:
             return __class__.FindPostmasterResult.create_not_found()
@@ -88,7 +88,7 @@ class InternalPlatformUtils(base.InternalPlatformUtils):
             msgs.append("Many processes like a postmaster are found: {}.".format(len(lines)))
 
             for i in range(len(lines)):
-                assert type(lines[i]) == str  # noqa: E721
+                assert type(lines[i]) is str
                 lines.append("[{}] '{}'".format(i, lines[i]))
                 continue
 
@@ -96,7 +96,7 @@ class InternalPlatformUtils(base.InternalPlatformUtils):
             return __class__.FindPostmasterResult.create_many_processes()
 
         def is_space_or_tab(ch) -> bool:
-            assert type(ch) == str  # noqa: E721
+            assert type(ch) is str
             return ch == " " or ch == "\t"
 
         line = lines[0]
@@ -115,6 +115,6 @@ class InternalPlatformUtils(base.InternalPlatformUtils):
             return __class__.FindPostmasterResult.create_has_problems()
 
         pid = int(line[start:pos])
-        assert type(pid) == int  # noqa: E721
+        assert type(pid) is int
 
         return __class__.FindPostmasterResult.create_ok(pid)

{testgres-1.13.5 → testgres-1.13.7}/src/impl/platforms/win32/internal_platform_utils.py

@@ -12,6 +12,6 @@ class InternalPlatformUtils(base.InternalPlatformUtils):
         data_dir: str
     ) -> InternalPlatformUtils.FindPostmasterResult:
         assert isinstance(os_ops, OsOperations)
-        assert type(bin_dir) == str  # noqa: E721
-        assert type(data_dir) == str  # noqa: E721
+        assert type(bin_dir) is str
+        assert type(data_dir) is str
         return __class__.FindPostmasterResult.create_not_implemented()

{testgres-1.13.5 → testgres-1.13.7}/src/impl/port_manager__generic.py

@@ -38,8 +38,8 @@ class PortManager__Generic(PortManager):
 
     def reserve_port(self) -> int:
         assert self._guard is not None
-        assert type(self._available_ports) == set  # noqa: E721t
-        assert type(self._reserved_ports) == set  # noqa: E721
+        assert type(self._available_ports) is set
+        assert type(self._reserved_ports) is set
 
         with self._guard:
             t = tuple(self._available_ports)
@@ -48,8 +48,8 @@ class PortManager__Generic(PortManager):
             t = None
 
             for port in sampled_ports:
-                assert type(port) == int  # noqa: E721
-                assert not (port in self._reserved_ports)
+                assert type(port) is int
+                assert port not in self._reserved_ports
                 assert port in self._available_ports
 
                 assert port >= __class__._C_MIN_PORT_NUMBER
@@ -61,26 +61,26 @@ class PortManager__Generic(PortManager):
                 self._reserved_ports.add(port)
                 self._available_ports.discard(port)
                 assert port in self._reserved_ports
-                assert not (port in self._available_ports)
+                assert port not in self._available_ports
                 __class__.helper__send_debug_msg("Port {} is reserved.", port)
                 return port
 
         raise PortForException("Can't select a port.")
 
     def release_port(self, number: int) -> None:
-        assert type(number) == int  # noqa: E721
+        assert type(number) is int
         assert number >= __class__._C_MIN_PORT_NUMBER
         assert number <= __class__._C_MAX_PORT_NUMBER
 
         assert self._guard is not None
-        assert type(self._reserved_ports) == set  # noqa: E721
+        assert type(self._reserved_ports) is set
 
         with self._guard:
             assert number in self._reserved_ports
-            assert not (number in self._available_ports)
+            assert number not in self._available_ports
             self._available_ports.add(number)
             self._reserved_ports.discard(number)
-            assert not (number in self._reserved_ports)
+            assert number not in self._reserved_ports
             assert number in self._available_ports
             __class__.helper__send_debug_msg("Port {} is released.", number)
         return
@@ -89,8 +89,8 @@ class PortManager__Generic(PortManager):
     def helper__send_debug_msg(msg_template: str, *args) -> None:
         assert msg_template is not None
         assert args is not None
-        assert type(msg_template) == str  # noqa: E721
-        assert type(args) == tuple  # noqa: E721
+        assert type(msg_template) is str
+        assert type(args) is tuple
         assert msg_template != ""
         s = "[port manager] "
         s += msg_template.format(*args)

{testgres-1.13.5 → testgres-1.13.7}/src/impl/port_manager__this_host.py

@@ -15,19 +15,19 @@ class PortManager__ThisHost(PortManager):
         assert __class__.sm_single_instance_guard is not None
 
         if __class__.sm_single_instance is not None:
-            assert type(__class__.sm_single_instance) == __class__  # noqa: E721
+            assert type(__class__.sm_single_instance) is __class__
             return __class__.sm_single_instance
 
         with __class__.sm_single_instance_guard:
             if __class__.sm_single_instance is None:
                 __class__.sm_single_instance = __class__()
         assert __class__.sm_single_instance is not None
-        assert type(__class__.sm_single_instance) == __class__  # noqa: E721
+        assert type(__class__.sm_single_instance) is __class__
         return __class__.sm_single_instance
 
     def reserve_port(self) -> int:
         return utils.reserve_port()
 
     def release_port(self, number: int) -> None:
-        assert type(number) == int  # noqa: E721
+        assert type(number) is int
         return utils.release_port(number)