Updates vendored subliminal to 2.1.0

Updates rarfile to 3.1
Updates stevedore to 3.5.0
Updates appdirs to 1.4.4
Updates click to 8.1.3
Updates decorator to 5.1.1
Updates dogpile.cache to 1.1.8
Updates pbr to 5.11.0
Updates pysrt to 1.1.2
Updates pytz to 2022.6
Adds importlib-metadata version 3.1.1
Adds typing-extensions version 4.1.1
Adds zipp version 3.11.0

libs/common/stevedore/tests/test_cache.py

@@ -0,0 +1,56 @@
+#  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.
+
+"""Tests for stevedore._cache
+"""
+import sys
+
+from unittest import mock
+
+from stevedore import _cache
+from stevedore.tests import utils
+
+
+class TestCache(utils.TestCase):
+
+    def test_disable_caching_executable(self):
+        """Test caching is disabled if python interpreter is located under /tmp
+        directory (Ansible)
+        """
+        with mock.patch.object(sys, 'executable', '/tmp/fake'):
+            sot = _cache.Cache()
+            self.assertTrue(sot._disable_caching)
+
+    def test_disable_caching_file(self):
+        """Test caching is disabled if .disable file is present in target
+        dir
+        """
+        cache_dir = _cache._get_cache_dir()
+
+        with mock.patch('os.path.isfile') as mock_path:
+            mock_path.return_value = True
+            sot = _cache.Cache()
+            mock_path.assert_called_with('%s/.disable' % cache_dir)
+            self.assertTrue(sot._disable_caching)
+
+            mock_path.return_value = False
+            sot = _cache.Cache()
+            self.assertFalse(sot._disable_caching)
+
+    @mock.patch('os.makedirs')
+    @mock.patch('builtins.open')
+    def test__get_data_for_path_no_write(self, mock_open, mock_mkdir):
+        sot = _cache.Cache()
+        sot._disable_caching = True
+        mock_open.side_effect = IOError
+        sot._get_data_for_path('fake')
+        mock_mkdir.assert_not_called()

libs/common/stevedore/tests/test_callback.py

@@ -12,8 +12,9 @@
 
 """Tests for failure loading callback
 """
+from unittest import mock
+
 from testtools.matchers import GreaterThan
-import mock
 
 from stevedore import extension
 from stevedore import named

libs/common/stevedore/tests/test_dispatch.py

@@ -10,8 +10,8 @@
 #  License for the specific language governing permissions and limitations
 #  under the License.
 
-from stevedore.tests import utils
 from stevedore import dispatch
+from stevedore.tests import utils
 
 
 def check_dispatch(ep, *args, **kwds):

libs/common/stevedore/tests/test_driver.py

@@ -13,7 +13,12 @@
 """Tests for stevedore.extension
 """
 
-import pkg_resources
+try:
+    # For python 3.8 and later
+    import importlib.metadata as importlib_metadata
+except ImportError:
+    # For everyone else
+    import importlib_metadata
 
 from stevedore import driver
 from stevedore import exception
@@ -68,13 +73,15 @@ class TestCallback(utils.TestCase):
         extensions = [
             extension.Extension(
                 'backend',
-                pkg_resources.EntryPoint.parse('backend = pkg1:driver'),
+                importlib_metadata.EntryPoint(
+                    'backend', 'pkg1:driver', 'backend'),
                 'pkg backend',
                 None,
             ),
             extension.Extension(
                 'backend',
-                pkg_resources.EntryPoint.parse('backend = pkg2:driver'),
+                importlib_metadata.EntryPoint(
+                    'backend', 'pkg2:driver', 'backend'),
                 'pkg backend',
                 None,
             ),

libs/common/stevedore/tests/test_extension.py

@@ -14,8 +14,14 @@
 """
 
 import operator
+from unittest import mock
 
-import mock
+try:
+    # For python 3.8 and later
+    import importlib.metadata as importlib_metadata
+except ImportError:
+    # For everyone else
+    import importlib_metadata
 
 from stevedore import exception
 from stevedore import extension
@@ -97,13 +103,13 @@ class TestCallback(utils.TestCase):
 
     def test_use_cache(self):
         # If we insert something into the cache of entry points,
-        # the manager should not have to call into pkg_resources
+        # the manager should not have to call into entrypoints
         # to find the plugins.
         cache = extension.ExtensionManager.ENTRY_POINT_CACHE
         cache['stevedore.test.faux'] = []
-        with mock.patch('pkg_resources.iter_entry_points',
+        with mock.patch('stevedore._cache.get_group_all',
                         side_effect=
-                        AssertionError('called iter_entry_points')):
+                        AssertionError('called get_group_all')):
             em = extension.ExtensionManager('stevedore.test.faux')
             names = em.names()
         self.assertEqual(names, [])
@@ -236,9 +242,48 @@ class TestLoadRequirementsOldSetuptools(utils.TestCase):
     def test_verify_requirements(self):
         self.em._load_one_plugin(self.mock_ep, False, (), {},
                                  verify_requirements=True)
-        self.mock_ep.load.assert_called_once_with(require=True)
+        self.mock_ep.load.assert_called_once_with()
 
     def test_no_verify_requirements(self):
         self.em._load_one_plugin(self.mock_ep, False, (), {},
                                  verify_requirements=False)
-        self.mock_ep.load.assert_called_once_with(require=False)
+        self.mock_ep.load.assert_called_once_with()
+
+
+class TestExtensionProperties(utils.TestCase):
+
+    def setUp(self):
+        self.ext1 = extension.Extension(
+            'name',
+            importlib_metadata.EntryPoint(
+                'name', 'module.name:attribute.name [extra]', 'group_name',
+            ),
+            mock.Mock(),
+            None,
+        )
+        self.ext2 = extension.Extension(
+            'name',
+            importlib_metadata.EntryPoint(
+                'name', 'module:attribute', 'group_name',
+            ),
+            mock.Mock(),
+            None,
+        )
+
+    def test_module_name(self):
+        self.assertEqual('module.name', self.ext1.module_name)
+        self.assertEqual('module', self.ext2.module_name)
+
+    def test_extras(self):
+        self.assertEqual(['[extra]'], self.ext1.extras)
+        self.assertEqual([], self.ext2.extras)
+
+    def test_attr(self):
+        self.assertEqual('attribute.name', self.ext1.attr)
+        self.assertEqual('attribute', self.ext2.attr)
+
+    def test_entry_point_target(self):
+        self.assertEqual('module.name:attribute.name [extra]',
+                         self.ext1.entry_point_target)
+        self.assertEqual('module:attribute',
+                         self.ext2.entry_point_target)

libs/common/stevedore/tests/test_named.py

@@ -10,11 +10,11 @@
 #  License for the specific language governing permissions and limitations
 #  under the License.
 
+from unittest import mock
+
 from stevedore import named
 from stevedore.tests import utils
 
-import mock
-
 
 class TestNamed(utils.TestCase):
     def test_named(self):

libs/common/stevedore/tests/test_sphinxext.py

@@ -12,25 +12,26 @@
 """Tests for the sphinx extension
 """
 
-from __future__ import unicode_literals
+try:
+    # For python 3.8 and later
+    import importlib.metadata as importlib_metadata
+except ImportError:
+    # For everyone else
+    import importlib_metadata
 
 from stevedore import extension
 from stevedore import sphinxext
 from stevedore.tests import utils
 
-import mock
-import pkg_resources
-
 
 def _make_ext(name, docstring):
     def inner():
         pass
 
     inner.__doc__ = docstring
-    m1 = mock.Mock(spec=pkg_resources.EntryPoint)
-    m1.module_name = '%s_module' % name
-    s = mock.Mock(return_value='ENTRY_POINT(%s)' % name)
-    m1.__str__ = s
+    m1 = importlib_metadata.EntryPoint(
+        name, '{}_module:{}'.format(name, name), 'group',
+    )
     return extension.Extension(name, m1, inner, None)
 
 
@@ -112,7 +113,8 @@ class TestSphinxExt(utils.TestCase):
                 ('nodoc', 'nodoc_module'),
                 ('-----', 'nodoc_module'),
                 ('\n', 'nodoc_module'),
-                ('.. warning:: No documentation found in ENTRY_POINT(nodoc)',
+                (('.. warning:: No documentation found for '
+                 'nodoc in nodoc_module:nodoc'),
                  'nodoc_module'),
                 ('\n', 'nodoc_module'),
             ],

libs/common/stevedore/tests/test_test_manager.py

@@ -10,14 +10,20 @@
 #  License for the specific language governing permissions and limitations
 #  under the License.
 
-from mock import Mock, sentinel
-from stevedore import (ExtensionManager, NamedExtensionManager, HookManager,
-                       DriverManager, EnabledExtensionManager)
-from stevedore.dispatch import (DispatchExtensionManager,
-                                NameDispatchExtensionManager)
+from unittest.mock import Mock
+from unittest.mock import sentinel
+
+from stevedore.dispatch import DispatchExtensionManager
+from stevedore.dispatch import NameDispatchExtensionManager
 from stevedore.extension import Extension
 from stevedore.tests import utils
 
+from stevedore import DriverManager
+from stevedore import EnabledExtensionManager
+from stevedore import ExtensionManager
+from stevedore import HookManager
+from stevedore import NamedExtensionManager
+
 
 test_extension = Extension('test_extension', None, None, None)
 test_extension2 = Extension('another_one', None, None, None)