Replace ModuleDiscovery class with plain functions and reduce hardcode amount (#233)

Author: sergey-bondarenko-qs

.github/workflows/testing.yml

@@ -18,7 +18,7 @@ jobs:
     - name: Install and configure Poetry
       uses: snok/install-poetry@v1
       with:
-        version: latest
+        version: 1.1.10
     - name: Install dependencies
       run: poetry install
     - name: Test with pytest

CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [11.0.0]
+### Added
+- get_all_subclasses function in module_discovery module
+### Changed
+- Refactor ModuleDiscovery to functions
+
 ## [10.0.1]
 - Register ThrottleException as a global to simplify projects without throttling
 - Add Swagger UI which do not rely on drf_yasg and static file server: winter_openapi.get_swagger_ui_html

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "winter"
-version = "10.0.1"
+version = "11.0.0"
 homepage = "https://github.com/WinterFramework/winter"
 description = "Web Framework inspired by Spring Framework"
 authors = ["Alexander Egorov <[email protected]>"]

tests/core/test_module_discovery.py

@@ -0,0 +1,32 @@
+import mock
+
+from winter.core import WinterApplication
+from winter.core.module_discovery import get_all_subclasses
+from winter.core.module_discovery import get_all_classes
+
+
+def test_module_import():
+    found_classes = get_all_classes()
+    # Verifying that some class (it can be any class) could be found
+    assert ('WinterApplication', WinterApplication) in found_classes
+
+
+@mock.patch('inspect.getmembers')
+def test_module_import_with_exception(getmembers):
+    # Verifying that import error during search of class will not stop the search
+    getmembers.side_effect = ImportError
+    found_classes = get_all_classes()
+    # It can't find any class, beacuse we have ImportError on any class
+    assert not found_classes
+
+
+def test_all_subclasses():
+    exception_subclasses = get_all_subclasses(Exception)
+    assert ('OverflowError', OverflowError) in exception_subclasses
+
+
+@mock.patch('_weakref.ReferenceType')
+def test_all_subclasses_with_exception(reference_type):
+    reference_type.side_effect = TypeError
+    exception_subclasses = get_all_subclasses(Exception)
+    assert not exception_subclasses

winter/core/__init__.py

@@ -11,5 +11,4 @@
 from .component_method_argument import ComponentMethodArgument
 from .injection import get_injector
 from .injection import set_injector
-from .module_discovery import ModuleDiscovery
 from .utils import cached_property

winter/core/module_discovery.py

@@ -7,27 +7,43 @@
 from typing import Type
 
 
-class ModuleDiscovery:
-    def get_all_classes(self, package: str = None) -> List[Tuple[str, Type]]:
-        classes = []
-        classes_set = set()
-        for module_name, module in dict(sys.modules).items():
-            if module_name.endswith('six.moves'):  # pragma: no cover
-                continue
+def get_all_classes(package: str = None) -> List[Tuple[str, Type]]:
+    classes = []
+    classes_set = set()
+    for module_name, module in dict(sys.modules).items():
+        try:
             for class_name, class_ in inspect.getmembers(module, inspect.isclass):
                 if class_ in classes_set:
                     continue
                 if package and not (isinstance(class_.__module__, str) and class_.__module__.startswith(package)):
                     continue
                 classes.append((class_name, class_))
                 classes_set.add(class_)
-        return classes
+        except ImportError:
+            pass
+    return classes
 
-    def import_recursively(self, package_name: str):
-        package = importlib.import_module(package_name)
-        for module in pkgutil.iter_modules(package.__path__):
-            child_name = package_name + '.' + module.name
-            if module.ispkg:
-                self.import_recursively(child_name)
-            else:
-                importlib.import_module(child_name)
+
+def get_all_subclasses(supertype: Type) -> List[Tuple[str, Type]]:
+    classes = []
+    for class_name, class_ in get_all_classes():
+        try:
+            # Workaround to not fail in the issubclass check
+            from _weakref import ReferenceType
+
+            ReferenceType(class_)
+        except TypeError:
+            continue
+        if class_ is not supertype and issubclass(class_, supertype):
+            classes.append((class_name, class_))
+    return classes
+
+
+def import_recursively(package_name: str):
+    package = importlib.import_module(package_name)
+    for module in pkgutil.iter_modules(package.__path__):
+        child_name = package_name + '.' + module.name
+        if module.ispkg:
+            import_recursively(child_name)
+        else:
+            importlib.import_module(child_name)

winter_django/autodiscovery.py

@@ -1,11 +1,11 @@
 import winter_django
-
-from winter.core import ModuleDiscovery
+from winter.core.module_discovery import import_recursively
+from winter.core.module_discovery import get_all_classes
 
 
 def create_django_urls_for_package(package_name: str):
-    ModuleDiscovery().import_recursively(package_name)
+    import_recursively(package_name)
     uripatterns = []
-    for class_name, cls in ModuleDiscovery().get_all_classes(package_name):
+    for class_name, cls in get_all_classes(package_name):
         uripatterns += winter_django.create_django_urls(cls)
     return uripatterns