Added new "import_tools" submodule.

Author: domdfcoding

domdf_python_tools/import_tools.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+#
+#  import_tools.py
+"""
+Functions for importing classes.
+"""
+#
+#  Copyright © 2020 Dominic Davis-Foster <[email protected]>
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#  MA 02110-1301, USA.
+#
+#  Based on https://github.com/asottile/git-code-debt/blob/master/git_code_debt/util/discovery.py
+#  Copyright (c) 2014 Anthony Sottile
+#  Licensed under the MIT License
+#  |  Permission is hereby granted, free of charge, to any person obtaining a copy
+#  |  of this software and associated documentation files (the "Software"), to deal
+#  |  in the Software without restriction, including without limitation the rights
+#  |  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#  |  copies of the Software, and to permit persons to whom the Software is
+#  |  furnished to do so, subject to the following conditions:
+#  |
+#  |  The above copyright notice and this permission notice shall be included in
+#  |  all copies or substantial portions of the Software.
+#  |
+#  |  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  |  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  |  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#  |  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#  |  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#  |  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+#  |  THE SOFTWARE.
+#
+
+# stdlib
+import inspect
+import pkgutil
+from types import ModuleType
+from typing import Any, Callable, List, Optional, Type
+
+
+def discover(
+		package: ModuleType,
+		match_func: Optional[Callable[[Any], bool]] = None,
+		) -> List[Type[Any]]:
+	"""
+	Returns a set of objects in the directory matched by match_func
+
+	:param package: A Python package
+	:param match_func: Function taking an object and returning true if the object is to be included in the output.
+
+	:return:
+	:rtype:
+	"""
+
+	matched_classes = list()
+
+	for _, module_name, _ in pkgutil.walk_packages(
+			# https://github.com/python/mypy/issues/1422
+			# Stalled PRs: https://github.com/python/mypy/pull/3527
+			#              https://github.com/python/mypy/pull/5212
+			package.__path__,  # type: ignore
+			prefix=package.__name__ + '.',
+			):
+		module = __import__(module_name, fromlist=['__trash'], level=0)
+
+		# Check all the functions in that module
+		for _, imported_objects in inspect.getmembers(module, match_func):
+			if not hasattr(imported_objects, "__module__"):
+				continue
+
+			# Don't include things that are only there due to a side effect of importing
+			if imported_objects.__module__ != module.__name__:
+				continue
+
+			matched_classes.append(imported_objects)
+
+	return matched_classes

domdf_python_tools/versions.py

@@ -99,7 +99,7 @@ def __eq__(self, other) -> bool:
 		other = _prep_for_eq(other)
 
 		if other is NotImplemented:
-			return NotImplemented
+			return NotImplemented  # pragma: no cover
 		else:
 			shortest = min(len(self), (len(other)))
 			return self[:shortest] == other[:shortest]
@@ -114,7 +114,7 @@ def __gt__(self, other) -> bool:
 		other = _prep_for_eq(other)
 
 		if other is NotImplemented:
-			return NotImplemented
+			return NotImplemented  # pragma: no cover
 		else:
 			return tuple(self) > other
 
@@ -128,7 +128,7 @@ def __lt__(self, other) -> bool:
 		other = _prep_for_eq(other)
 
 		if other is NotImplemented:
-			return NotImplemented
+			return NotImplemented  # pragma: no cover
 		else:
 			return tuple(self) < other
 
@@ -142,7 +142,7 @@ def __ge__(self, other) -> bool:
 		other = _prep_for_eq(other)
 
 		if other is NotImplemented:
-			return NotImplemented
+			return NotImplemented  # pragma: no cover
 		else:
 			return tuple(self)[:len(other)] >= other
 
@@ -156,7 +156,7 @@ def __le__(self, other) -> bool:
 		other = _prep_for_eq(other)
 
 		if other is NotImplemented:
-			return NotImplemented
+			return NotImplemented  # pragma: no cover
 		else:
 			return tuple(self)[:len(other)] <= other
 

tests/discover_demo_module/__init__.py

@@ -0,0 +1,6 @@
+def foo():
+	pass
+
+
+def bar():
+	pass

tests/discover_demo_module/submodule_a.py

@@ -0,0 +1,9 @@
+from string import ascii_letters
+from math import ceil
+
+class Bob():
+	pass
+
+
+class Alice():
+	pass

tests/discover_demo_module/submodule_b.py

@@ -0,0 +1,89 @@
+# stdlib
+import inspect
+import sys
+from contextlib import contextmanager
+
+# 3rd party
+import pytest
+
+# this package
+from domdf_python_tools.import_tools import discover
+
+sys.path.append(".")
+sys.path.append("tests")
+
+# 3rd partys
+import discover_demo_module
+
+
+def test_discover():
+	# Alphabetical order regardless of order in the module.
+	assert discover(discover_demo_module) == [
+			discover_demo_module.submodule_a.bar,
+			discover_demo_module.submodule_a.foo,
+			discover_demo_module.submodule_b.Alice,
+			discover_demo_module.submodule_b.Bob,
+			]
+
+
+def test_discover_function_only():
+	# Alphabetical order regardless of order in the module.
+	assert discover(discover_demo_module, match_func=inspect.isfunction) == [
+			discover_demo_module.submodule_a.bar,
+			discover_demo_module.submodule_a.foo,
+			]
+
+
+def test_discover_class_only():
+	# Alphabetical order regardless of order in the module.
+	assert discover(discover_demo_module, match_func=inspect.isclass) == [
+			discover_demo_module.submodule_b.Alice,
+			discover_demo_module.submodule_b.Bob,
+			]
+
+
+def test_discover_hasattr():
+
+	def match_func(obj):
+		return hasattr(obj, "foo")
+
+	assert discover(discover_demo_module, match_func=match_func) == []
+
+
+class HasPath:
+
+	__path__ = "foo"
+
+
+@contextmanager
+def does_not_raise():
+	yield
+
+
+if sys.version_info <= (3, 7):
+	haspath_error = does_not_raise()
+else:
+	haspath_error = pytest.raises(ValueError, match="^path must be None or list of paths to look for modules in$")
+
+
+def raises_attribute_error(obj, **kwargs):
+	return pytest.param(
+			obj,
+			pytest.raises(AttributeError, match=f"^'{type(obj).__name__}' object has no attribute '__path__'$"),
+			**kwargs,
+			)
+
+
+@pytest.mark.parametrize("obj, expects", [
+		raises_attribute_error("abc", id="string"),
+		raises_attribute_error(123, id="int"),
+		raises_attribute_error(12.34, id="float"),
+		raises_attribute_error([1, 2, 3], id="list"),
+		raises_attribute_error((1, 2, 3), id="tuple"),
+		raises_attribute_error({1, 2, 3}, id="set"),
+		raises_attribute_error({"a": 1, "b": 2, "c": 3}, id="dictionary"),
+		pytest.param(HasPath, haspath_error, id="HasPath"),
+		])
+def test_discover_errors(obj, expects):
+	with expects:
+		discover(obj)