Merge pull request piccolo-orm#13 from piccolo-orm/fixtures

Fixtures

Author: dantownsend

piccolo/apps/app/commands/show_all.py

@@ -1,13 +1,11 @@
+from piccolo.conf.apps import Finder
+
+
 def show_all():
     """
     Lists all registered Piccolo apps.
     """
-    try:
-        import piccolo_conf
-    except ImportError:
-        print("Unable to import piccolo_conf")
-
-    app_registry = getattr(piccolo_conf, "APP_REGISTRY")
+    app_registry = Finder().get_app_registry()
 
     print("Registered apps:")
 

piccolo/apps/migrations/commands/backwards.py

@@ -9,6 +9,7 @@ class BackwardsMigrationManager(BaseMigrationManager):
     def __init__(self, app_name: str, migration_id: str):
         self.migration_id = migration_id
         self.app_name = app_name
+        super().__init__()
 
     def run(self):
         app_modules = self.get_app_modules()

piccolo/apps/migrations/commands/base.py

@@ -1,24 +1,21 @@
 from __future__ import annotations
 import asyncio
-import functools
 import importlib
 import os
 import sys
 import typing as t
 
 from piccolo.conf.apps import (
-    AppConfig,
     MigrationModule,
-    PiccoloAppModule,
-    AppRegistry,
+    Finder,
 )
 from piccolo.apps.migrations.auto.migration_manager import MigrationManager
 from piccolo.apps.migrations.auto.diffable_table import DiffableTable
 from piccolo.apps.migrations.auto.schema_snapshot import SchemaSnapshot
 from piccolo.apps.migrations.tables import Migration
 
 
-class BaseMigrationManager:
+class BaseMigrationManager(Finder):
     def create_migration_table(self) -> bool:
         """
         Creates the migration table in the database. Returns True/False
@@ -29,90 +26,6 @@ def create_migration_table(self) -> bool:
             return True
         return False
 
-    def _deduplicate(
-        self, config_modules: t.List[PiccoloAppModule]
-    ) -> t.List[PiccoloAppModule]:
-        """
-        Remove all duplicates - just leaving the first instance.
-        """
-        # Deduplicate, but preserve order - which is why set() isn't used.
-        return list(dict([(c, None) for c in config_modules]).keys())
-
-    def _import_app_modules(
-        self, config_module_paths: t.List[str]
-    ) -> t.List[PiccoloAppModule]:
-        """
-        Import all piccolo_app.py modules, and all dependencies.
-        """
-        config_modules = []
-
-        for config_module_path in config_module_paths:
-            try:
-                config_module = t.cast(
-                    PiccoloAppModule,
-                    importlib.import_module(config_module_path),
-                )
-            except ImportError:
-                raise Exception(f"Unable to import {config_module_path}")
-            app_config: AppConfig = getattr(config_module, "APP_CONFIG")
-            dependency_config_modules = self._import_app_modules(
-                app_config.migration_dependencies
-            )
-            config_modules.extend(dependency_config_modules + [config_module])
-
-        return config_modules
-
-    def get_app_registry(self) -> AppRegistry:
-        try:
-            from piccolo_conf import APP_REGISTRY
-        except ImportError:
-            raise Exception(
-                "Unable to import APP_REGISTRY from piccolo_conf - make sure "
-                "it's in your path."
-            )
-        return APP_REGISTRY
-
-    def get_app_modules(self) -> t.List[PiccoloAppModule]:
-        """
-        Returns the piccolo_app.py modules for each registered Piccolo app.
-        """
-        app_registry = self.get_app_registry()
-        app_modules = self._import_app_modules(app_registry.apps)
-
-        # Now deduplicate any dependencies
-        app_modules = self._deduplicate(app_modules)
-
-        return app_modules
-
-    def get_sorted_app_names(self) -> t.List[str]:
-        """
-        Sorts the app names using the migration dependencies, so dependencies
-        are before dependents in the list.
-        """
-        modules = self.get_app_modules()
-        configs: t.List[AppConfig] = [module.APP_CONFIG for module in modules]
-
-        def sort_app_configs(app_config_1: AppConfig, app_config_2: AppConfig):
-            return (
-                app_config_1 in app_config_2.migration_dependency_app_configs
-            )
-
-        sorted_configs = sorted(
-            configs, key=functools.cmp_to_key(sort_app_configs)
-        )
-        return [i.app_name for i in sorted_configs]
-
-    def get_app_config(self, app_name: str) -> AppConfig:
-        """
-        Returns an `AppConfig` for the given app name.
-        """
-        modules = self.get_app_modules()
-        for module in modules:
-            app_config = module.APP_CONFIG
-            if app_config.app_name == app_name:
-                return app_config
-        raise ValueError(f"No app found with name {app_name}")
-
     def get_migration_modules(
         self, folder_path: str
     ) -> t.Dict[str, MigrationModule]:

piccolo/apps/migrations/commands/check.py

@@ -6,6 +6,7 @@
 class CheckMigrationManager(BaseMigrationManager):
     def __init__(self, app_name: str):
         self.app_name = app_name
+        super().__init__()
 
     def run(self):
         print("Listing migrations ...")

piccolo/apps/migrations/commands/forwards.py

@@ -22,6 +22,7 @@ def __init__(
         self.app_name = app_name
         self.migration_id = migration_id
         self.fake = fake
+        super().__init__()
 
     def run_migrations(self, app_config: AppConfig) -> None:
         already_ran = Migration.get_migrations_which_ran(

piccolo/apps/migrations/commands/new.py

@@ -11,7 +11,7 @@
 
 from .base import BaseMigrationManager
 from piccolo import __VERSION__
-from piccolo.conf.apps import AppConfig, AppRegistry
+from piccolo.conf.apps import AppConfig, Finder
 from piccolo.apps.migrations.auto import (
     AlterStatements,
     SchemaSnapshot,
@@ -149,26 +149,12 @@ def new(app_name: str, auto: bool = False):
     """
     print("Creating new migration ...")
 
-    try:
-        import piccolo_conf
-    except ImportError:
-        print("Can't find piccolo_conf")
-        sys.exit(1)
-
-    if auto and isinstance(getattr(piccolo_conf, "DB"), SQLiteEngine):
+    engine = Finder().get_engine()
+    if auto and isinstance(engine, SQLiteEngine):
         print("Auto migrations aren't currently supported by SQLite.")
         sys.exit(1)
 
-    try:
-        app_registry: AppRegistry = piccolo_conf.APP_REGISTRY
-    except AttributeError:
-        print("APP_REGISTRY isn't defined in piccolo_conf")
-        sys.exit(1)
-
-    app_config = app_registry.get_app_config(app_name)
-
-    if not app_config:
-        raise ValueError(f"Unrecognised app_name: {app_name}")
+    app_config = Finder().get_app_config(app_name=app_name)
 
     _create_migrations_folder(app_config.migrations_folder_path)
     _create_new_migration(app_config=app_config, auto=auto)

piccolo/apps/shell/commands/run.py

@@ -1,7 +1,7 @@
 import sys
 import typing as t
 
-from piccolo.conf.apps import AppRegistry, AppConfig
+from piccolo.conf.apps import AppRegistry, AppConfig, Finder
 from piccolo.table import Table
 
 
@@ -28,13 +28,7 @@ def run():
     Runs an iPython shell, and automatically imports all of the Table classes
     from your project.
     """
-    try:
-        import piccolo_conf
-    except ImportError:
-        print("Can't find piccolo_conf")
-        sys.exit(1)
-
-    app_registry: AppRegistry = piccolo_conf.APP_REGISTRY
+    app_registry: AppRegistry = Finder().get_app_registry()
 
     tables = {}
     spacer = "-------"