export only try_import in __all__

bp graduate-oslo-utils
Change-Id: I63533746d0f4a45aa9f21d235c0353300c8af4cb

2 files changed, 36 insertions, 36 deletions

diff --git a/oslo/utils/importutils.py b/oslo/utils/importutils.py
index 043f817..f706ec5 100644
--- a/oslo/utils/importutils.py
+++ b/oslo/utils/importutils.py
@@ -21,7 +21,7 @@ import sys
 import traceback
 
 
-def import_class(import_str):
+def _import_class(import_str):
     """Returns a class from a string including module and class."""
     mod_str, _sep, class_str = import_str.rpartition('.')
     __import__(mod_str)
@@ -33,12 +33,12 @@ def import_class(import_str):
                            traceback.format_exception(*sys.exc_info())))
 
 
-def import_object(import_str, *args, **kwargs):
+def _import_object(import_str, *args, **kwargs):
     """Import a class and return an instance of it."""
-    return import_class(import_str)(*args, **kwargs)
+    return _import_class(import_str)(*args, **kwargs)
 
 
-def import_object_ns(name_space, import_str, *args, **kwargs):
+def _import_object_ns(name_space, import_str, *args, **kwargs):
     """Tries to import object from default namespace.
 
     Imports a class and return an instance of it, first by trying
@@ -47,27 +47,27 @@ def import_object_ns(name_space, import_str, *args, **kwargs):
     """
     import_value = "%s.%s" % (name_space, import_str)
     try:
-        return import_class(import_value)(*args, **kwargs)
+        return _import_class(import_value)(*args, **kwargs)
     except ImportError:
-        return import_class(import_str)(*args, **kwargs)
+        return _import_class(import_str)(*args, **kwargs)
 
 
-def import_module(import_str):
+def _import_module(import_str):
     """Import a module."""
     __import__(import_str)
     return sys.modules[import_str]
 
 
-def import_versioned_module(version, submodule=None):
+def _import_versioned_module(version, submodule=None):
     module = 'oslo.v%s' % version
     if submodule:
         module = '.'.join((module, submodule))
-    return import_module(module)
+    return _import_module(module)
 
 
 def try_import(import_str, default=None):
     """Try to import a module and if it fails return default."""
     try:
-        return import_module(import_str)
+        return _import_module(import_str)
     except ImportError:
         return default
diff --git a/tests/test_importutils.py b/tests/test_importutils.py
index 579bf76..3a54d78 100644
--- a/tests/test_importutils.py
+++ b/tests/test_importutils.py
@@ -27,85 +27,85 @@ class ImportUtilsTest(test_base.BaseTestCase):
     #                __import__ is the devil. Right now we just make
     #               sure we can import something from the stdlib
     def test_import_class(self):
-        dt = importutils.import_class('datetime.datetime')
+        dt = importutils._import_class('datetime.datetime')
         self.assertEqual(sys.modules['datetime'].datetime, dt)
 
     def test_import_bad_class(self):
-        self.assertRaises(ImportError, importutils.import_class,
+        self.assertRaises(ImportError, importutils._import_class,
                           'lol.u_mad.brah')
 
     def test_import_module(self):
-        dt = importutils.import_module('datetime')
+        dt = importutils._import_module('datetime')
         self.assertEqual(sys.modules['datetime'], dt)
 
     def test_import_object_optional_arg_not_present(self):
-        obj = importutils.import_object('tests.fake.FakeDriver')
+        obj = importutils._import_object('tests.fake.FakeDriver')
         self.assertEqual(obj.__class__.__name__, 'FakeDriver')
 
     def test_import_object_optional_arg_present(self):
-        obj = importutils.import_object('tests.fake.FakeDriver',
-                                        first_arg=False)
+        obj = importutils._import_object('tests.fake.FakeDriver',
+                                         first_arg=False)
         self.assertEqual(obj.__class__.__name__, 'FakeDriver')
 
     def test_import_object_required_arg_not_present(self):
         # arg 1 isn't optional here
-        self.assertRaises(TypeError, importutils.import_object,
+        self.assertRaises(TypeError, importutils._import_object,
                           'tests.fake.FakeDriver2')
 
     def test_import_object_required_arg_present(self):
-        obj = importutils.import_object('tests.fake.FakeDriver2',
-                                        first_arg=False)
+        obj = importutils._import_object('tests.fake.FakeDriver2',
+                                         first_arg=False)
         self.assertEqual(obj.__class__.__name__, 'FakeDriver2')
 
     # namespace tests
     def test_import_object_ns_optional_arg_not_present(self):
-        obj = importutils.import_object_ns('tests', 'fake.FakeDriver')
+        obj = importutils._import_object_ns('tests', 'fake.FakeDriver')
         self.assertEqual(obj.__class__.__name__, 'FakeDriver')
 
     def test_import_object_ns_optional_arg_present(self):
-        obj = importutils.import_object_ns('tests', 'fake.FakeDriver',
-                                           first_arg=False)
+        obj = importutils._import_object_ns('tests', 'fake.FakeDriver',
+                                            first_arg=False)
         self.assertEqual(obj.__class__.__name__, 'FakeDriver')
 
     def test_import_object_ns_required_arg_not_present(self):
         # arg 1 isn't optional here
-        self.assertRaises(TypeError, importutils.import_object_ns,
+        self.assertRaises(TypeError, importutils._import_object_ns,
                           'tests', 'fake.FakeDriver2')
 
     def test_import_object_ns_required_arg_present(self):
-        obj = importutils.import_object_ns('tests', 'fake.FakeDriver2',
-                                           first_arg=False)
+        obj = importutils._import_object_ns('tests', 'fake.FakeDriver2',
+                                            first_arg=False)
         self.assertEqual(obj.__class__.__name__, 'FakeDriver2')
 
     # namespace tests
     def test_import_object_ns_full_optional_arg_not_present(self):
-        obj = importutils.import_object_ns('tests2',
-                                           'tests.fake.FakeDriver')
+        obj = importutils._import_object_ns('tests2',
+                                            'tests.fake.FakeDriver')
         self.assertEqual(obj.__class__.__name__, 'FakeDriver')
 
     def test_import_object_ns_full_optional_arg_present(self):
-        obj = importutils.import_object_ns('tests2',
-                                           'tests.fake.FakeDriver',
-                                           first_arg=False)
+        obj = importutils._import_object_ns('tests2',
+                                            'tests.fake.FakeDriver',
+                                            first_arg=False)
         self.assertEqual(obj.__class__.__name__, 'FakeDriver')
 
     def test_import_object_ns_full_required_arg_not_present(self):
         # arg 1 isn't optional here
-        self.assertRaises(TypeError, importutils.import_object_ns,
+        self.assertRaises(TypeError, importutils._import_object_ns,
                           'tests2', 'tests.fake.FakeDriver2')
 
     def test_import_object_ns_full_required_arg_present(self):
-        obj = importutils.import_object_ns('tests2',
-                                           'tests.fake.FakeDriver2',
-                                           first_arg=False)
+        obj = importutils._import_object_ns('tests2',
+                                            'tests.fake.FakeDriver2',
+                                            first_arg=False)
         self.assertEqual(obj.__class__.__name__, 'FakeDriver2')
 
     def test_import_object(self):
-        dt = importutils.import_object('datetime.time')
+        dt = importutils._import_object('datetime.time')
         self.assertTrue(isinstance(dt, sys.modules['datetime'].time))
 
     def test_import_object_with_args(self):
-        dt = importutils.import_object('datetime.datetime', 2012, 4, 5)
+        dt = importutils._import_object('datetime.datetime', 2012, 4, 5)
         self.assertTrue(isinstance(dt, sys.modules['datetime'].datetime))
         self.assertEqual(dt, datetime.datetime(2012, 4, 5))