educommon 3.12.0__py3-none-any.whl → 3.13.2__py3-none-any.whl

educommon/django/db/partitioning/__init__.py

@@ -28,6 +28,7 @@
 Подробнее о партиционировании можно почитать в дкоументации PostgreSQL
 (раздел 5.9).
 """
+
 import re
 from contextlib import (
     closing,
@@ -86,24 +87,18 @@ _MESSAGE_PREFIX = '[Partitioning] '
 def _check_system_settings(database_alias):
     """Проверка конфигурации системы. Перечень проверок:
 
-        1. Указанный алиас БД есть в конфигурации системы.
-        2. Указанная БД управляется СУБД PostgreSQL.
+    1. Указанный алиас БД есть в конфигурации системы.
+    2. Указанная БД управляется СУБД PostgreSQL.
     """
     if database_alias not in settings.DATABASES:
-        raise ImproperlyConfigured(
-            _MESSAGE_PREFIX +
-            '"{0}" database not found.'.format(database_alias)
-        )
+        raise ImproperlyConfigured(f'{_MESSAGE_PREFIX}"{database_alias}" database not found.')
 
     database_engine = settings.DATABASES[database_alias]['ENGINE']
     if database_engine not in (
         'django.db.backends.postgresql_psycopg2',
         'django.db.backends.postgresql',
     ):
-        raise ImproperlyConfigured(
-            _MESSAGE_PREFIX +
-            'only PostgreSQL DBMS supported.'
-        )
+        raise ImproperlyConfigured(f'{_MESSAGE_PREFIX}only PostgreSQL DBMS supported.')
 
 
 def is_initialized(database_alias):
@@ -116,9 +111,7 @@ def is_initialized(database_alias):
     """
     # Проверка наличия схемы partitioning.
     with closing(connections[database_alias].cursor()) as cursor:
-        cursor.execute(
-            "select 1 from pg_namespace where nspname = 'partitioning'"
-        )
+        cursor.execute("select 1 from pg_namespace where nspname = 'partitioning'")
         if cursor.fetchone() is None:
             return False
 
@@ -127,12 +120,12 @@ def is_initialized(database_alias):
     for function_name in function_names:
         with closing(connections[database_alias].cursor()) as cursor:
             cursor.execute(
-                "select 1 "
-                "from pg_proc proc "
-                "inner join pg_namespace ns on ns.oid = proc.pronamespace "
+                'select 1 '
+                'from pg_proc proc '
+                'inner join pg_namespace ns on ns.oid = proc.pronamespace '
                 "where proc.proname = %s and ns.nspname = 'partitioning' "
-                "limit 1",
-                [function_name]
+                'limit 1',
+                [function_name],
             )
             if cursor.fetchone() is None:
                 return False
@@ -141,6 +134,7 @@ def is_initialized(database_alias):
 
 
 def _execute_sql_file(database_alias, file_name, params=None):
+    """Выполняет SQL-скрипт из файла с подстановкой параметров."""
     cursor = connections[database_alias].cursor()
 
     file_path = path.join(path.dirname(__file__), file_name)
@@ -173,16 +167,19 @@ def init(database_alias=DEFAULT_DB_ALIAS, force=False):
     _check_system_settings(database_alias)
 
     if not force and is_initialized(database_alias):
-        raise ImproperlyConfigured(
-            _MESSAGE_PREFIX + 'always initialized'
-        )
-
-    _execute_sql_file(database_alias, 'partitioning.sql', dict(
-        view_name_suffix=PartitioningObserver.view_name_suffix,
-    ))
+        raise ImproperlyConfigured(f'{_MESSAGE_PREFIX}always initialized')
+
+    _execute_sql_file(
+        database_alias,
+        'partitioning.sql',
+        dict(
+            view_name_suffix=PartitioningObserver.view_name_suffix,
+        ),
+    )
 
 
 def _get_model_params(model):
+    """Возвращает параметры модели: алиас БД, имя таблицы и имя PK-колонки."""
     database_alias = router.db_for_write(model)
     table_name = model._meta.db_table
     pk_column_name = model._meta.pk.name
@@ -198,16 +195,12 @@ def is_model_partitioned(model):
     database_alias, table_name, _ = _get_model_params(model)
 
     with closing(connections[database_alias].cursor()) as cursor:
-        cursor.execute(
-            "select 1 from pg_namespace where nspname = 'partitioning' limit 1"
-        )
+        cursor.execute("select 1 from pg_namespace where nspname = 'partitioning' limit 1")
         if cursor.fetchone() is None:
             return False
 
-        cursor.execute(
-            "select partitioning.is_table_partitioned(%s)",
-            (table_name,)
-        )
+        cursor.execute('select partitioning.is_table_partitioned(%s)', (table_name,))
+
         return cursor.fetchone()[0]
 
 
@@ -236,14 +229,12 @@ def set_partitioning_for_model(model, column_name, force=False):
     ModelOptions(model).get_field(column_name)
 
     if not force and not is_initialized(database_alias):
-        raise ImproperlyConfigured(
-            _MESSAGE_PREFIX + 'not initialized'
-        )
+        raise ImproperlyConfigured(f'{_MESSAGE_PREFIX}not initialized')
 
     _execute_sql_file(database_alias, 'triggers.sql', locals())
 
 
-def split_table(model, column_name: str, timeout: float = 0,  cursor_itersize: Optional[int] = None):
+def split_table(model, column_name: str, timeout: float = 0, cursor_itersize: Optional[int] = None):
     """Переносит записи из разбиваемой таблицы в ее разделы.
 
     Недостающие разделы будут созданы автоматически.
@@ -271,20 +262,13 @@ def split_table(model, column_name: str, timeout: float = 0,  cursor_itersize: O
     ModelOptions(model).get_field(column_name)
 
     if not is_initialized(database_alias):
-        raise ImproperlyConfigured(
-            _MESSAGE_PREFIX + 'not initialized'
-        )
+        raise ImproperlyConfigured(f'{_MESSAGE_PREFIX}not initialized')
 
     if not is_model_partitioned(model):
-        raise ImproperlyConfigured(
-            _MESSAGE_PREFIX + 'not applyed for {table_name}'.format(**locals())
-        )
+        raise ImproperlyConfigured(f'{_MESSAGE_PREFIX}not applyed for {table_name}')
 
     if settings.DATABASES[database_alias]['DISABLE_SERVER_SIDE_CURSORS']:
-        raise ImproperlyConfigured(
-            _MESSAGE_PREFIX + 'split_table does not '
-                              'support DISABLE_SERVER_SIDE_CURSORS.'
-        )
+        raise ImproperlyConfigured(f'{_MESSAGE_PREFIX}split_table does not support DISABLE_SERVER_SIDE_CURSORS.')
 
     connection = connections[database_alias]
 
@@ -297,9 +281,7 @@ def split_table(model, column_name: str, timeout: float = 0,  cursor_itersize: O
 
     move_cursor = connection.cursor()
 
-    results = cursor_iter(
-        ids_cursor, connection.features.empty_fetchmany_value, 1, cursor_itersize
-    )
+    results = cursor_iter(ids_cursor, connection.features.empty_fetchmany_value, 1, cursor_itersize)
     for rows in results:
         # Если всего одна запись, то используем строку, чтобы не получать ошибку sql-запроса на обновление
         if len(rows) == 1:
@@ -308,11 +290,13 @@ def split_table(model, column_name: str, timeout: float = 0,  cursor_itersize: O
             pk_column_values = tuple(pkv for (pkv,) in rows)
         # Этот update выполняется для того, чтобы сработала триггерная
         # функция partitioning.before_update.
-        move_cursor.execute((
-            'update {table_name} '
-            'set {pk_column_name} = {pk_column_name} '
-            'where {pk_column_name} in {pk_column_values}'
-        ).format(**locals()))
+        move_cursor.execute(
+            (
+                'update {table_name} '
+                'set {pk_column_name} = {pk_column_name} '
+                'where {pk_column_name} in {pk_column_values}'
+            ).format(**locals())
+        )
 
         if timeout:
             sleep(timeout)
@@ -344,23 +328,22 @@ def clear_table(model, column_name: str, column_value: str, timeout=0, cursor_it
     connection = connections[database_alias]
 
     if settings.DATABASES[database_alias]['DISABLE_SERVER_SIDE_CURSORS']:
-        raise ImproperlyConfigured(
-            _MESSAGE_PREFIX + 'clear_table does not '
-                              'support DISABLE_SERVER_SIDE_CURSORS.'
-        )
+        raise ImproperlyConfigured(f'{_MESSAGE_PREFIX}clear_table does not support DISABLE_SERVER_SIDE_CURSORS.')
 
     ids_cursor = connection.chunked_cursor()
     ids_cursor.execute(
         # сырой SQL используется для того, чтобы извлечь только записи
         # из родительской таблицы без записей, уже размещенных в разделах
-        "select {pk_column_name} from only {table_name} "
-        "where {column_name} < '{column_value}'".format(**locals())
+        "select {pk_column_name} from only {table_name} where {column_name} < '{column_value}'".format(**locals())
     )
 
     delete_cursor = connection.cursor()
 
     results = cursor_iter(
-        ids_cursor, connection.features.empty_fetchmany_value, 1, cursor_itersize,
+        ids_cursor,
+        connection.features.empty_fetchmany_value,
+        1,
+        cursor_itersize,
     )
     for rows in results:
         # Если всего одна запись, то используем строку, чтобы не получать ошибку sql-запроса на удаление
@@ -368,10 +351,9 @@ def clear_table(model, column_name: str, column_value: str, timeout=0, cursor_it
             pk_column_values = f'{rows[0]}'.replace(',', '')
         else:
             pk_column_values = tuple(pkv for (pkv,) in rows)
-        delete_cursor.execute((
-            'delete from {table_name} '
-            'where {pk_column_name} in {pk_column_values}'
-        ).format(**locals()))
+        delete_cursor.execute(
+            ('delete from {table_name} where {pk_column_name} in {pk_column_values}').format(**locals())
+        )
 
         if timeout:
             sleep(timeout)
@@ -391,17 +373,14 @@ def get_model_partitions(model):
     cursor = connection.cursor()
 
     cursor.execute(
-        "select inhrelid::regclass::text as partition_name "
-        "from pg_inherits "
+        'select inhrelid::regclass::text as partition_name '
+        'from pg_inherits '
         "where inhparent = '{}'::regclass::oid "
-        "order by partition_name"
-        .format(table_name)
-    )
-    return tuple(
-        partition_name
-        for (partition_name,) in cursor
+        'order by partition_name'.format(table_name)
     )
 
+    return tuple(partition_name for (partition_name,) in cursor)
+
 
 def reset_partition_constraints(model, column_name, partition_name):
     """Переустанавливает ограничения для указанного раздела.
@@ -422,8 +401,7 @@ def reset_partition_constraints(model, column_name, partition_name):
     cursor = connection.cursor()
 
     cursor.execute(
-        'select partitioning.set_partition_constraint(%s, %s, %s, %s)',
-        (partition_name, column_name, year, month)
+        'select partitioning.set_partition_constraint(%s, %s, %s, %s)', (partition_name, column_name, year, month)
     )
 
     commit_unless_managed(database_alias)
@@ -440,29 +418,27 @@ def drop_partitions_before_date(model, date):
     if is_model_partitioned(model):
         database_alias, table_name, _ = _get_model_params(model)
         all_partitions = get_model_partitions(model)
-        filter_partition_name = table_name + '_y{}m{}'.format(
-            date.year, date.strftime('%m')
-        )
-        filtered_partitions = filter(
-            lambda p: (p <= filter_partition_name), all_partitions
-        )
+        filter_partition_name = f'{table_name}_y{date.year}m{date.strftime("%m")}'
+        filtered_partitions = filter(lambda p: (p <= filter_partition_name), all_partitions)
         connection = connections[database_alias]
         with connection.cursor() as cursor:
             for partition in filtered_partitions:
-                cursor.execute(
-                    'DROP TABLE IF EXISTS {};'.format(partition)
-                )
+                cursor.execute('DROP TABLE IF EXISTS {};'.format(partition))
 
 
 def set_partitioned_function_search_path(database_alias: str, schema_names: Optional[str] = None):
-    """"Проставляет параметры поиска для существующих функций партицирования.
+    """ "Проставляет параметры поиска для существующих функций партицирования.
 
     Это необходимо для корректной работы с таблицами к которым обращаются как к внешним через postgres_fdw.
     """
     schema_names = schema_names or 'public'
-    _execute_sql_file(database_alias, 'partitioning_set_search_path.sql', dict(
-        schema_names=schema_names,
-    ))
+    _execute_sql_file(
+        database_alias,
+        'partitioning_set_search_path.sql',
+        dict(
+            schema_names=schema_names,
+        ),
+    )
 
 
 class PartitioningObserver(ModelObserverBase):
@@ -492,10 +468,8 @@ class PartitioningObserver(ModelObserverBase):
 
     @cached_property
     def _partitioning_ready(self):
-        return {
-            database_alias: is_initialized(database_alias)
-            for database_alias in connections
-        }
+        """Кэширует информацию о том, проинициализировано ли партиционирование в БД."""
+        return {database_alias: is_initialized(database_alias) for database_alias in connections}
 
     def _is_observable(self, model):
         """Возвращает True только для моделей с включенным партиционированием.

educommon/django/db/partitioning/management/commands/apply_partitioning.py

@@ -28,8 +28,8 @@ class Command(BaseCommand):
     для БД, в которой хранится переданная модель, а затем создает необходимые
     триггеры. Подробнее см. в `educommon.django.db.partitioning.init` и
     `educommon.django.db.partitioning.set_partitioning_for_model`.
-
     """
+
     help = 'Applies partitioning to the table.'  # noqa: A003
 
     def add_arguments(self, parser):
@@ -49,18 +49,8 @@ class Command(BaseCommand):
             type=str,
             help='Field name. It will be the partition key.',
         )
-        parser.add_argument(
-            '--is_foreign_table',
-            type=bool,
-            default=False,
-            help='Партицирование для внешних таблиц'
-        )
-        parser.add_argument(
-            '--schemas_names',
-            type=str,
-            default=None,
-            help='Cхемы внешних таблиц при партицировании.'
-        )
+        parser.add_argument('--is_foreign_table', type=bool, default=False, help='Партицирование для внешних таблиц')
+        parser.add_argument('--schemas_names', type=str, default=None, help='Cхемы внешних таблиц при партицировании.')
 
     def handle(self, *args, **options):
         """Выполнение команды."""

educommon/django/db/partitioning/management/commands/clear_table.py

@@ -1,6 +1,3 @@
-from django.core.exceptions import (
-    FieldDoesNotExist,
-)
 from django.core.management.base import (
     CommandError,
 )
@@ -24,14 +21,12 @@ class Command(BaseCommand):
     С помощью данной команды удаляются записи из основной (не секционированной)
     таблицы, у которых значение в field_name меньше значения из before_value.
     Подробнее см. в `educommon.django.db.partitioning.clear_table`.
-
     """
-    help = (
-        'Command deletes all the records from database table when '
-        'field_name < before_value.'
-    )
+
+    help = 'Command deletes all the records from database table when field_name < before_value.'
 
     def add_arguments(self, parser):
+        """Добавляет аргументы командной строки для команды очистки таблицы."""
         parser.add_argument(
             '--app_label',
             type=str,
@@ -53,19 +48,28 @@ class Command(BaseCommand):
             help='Deleting rows before this value.',
         )
         parser.add_argument(
-            '--timeout', action='store', dest='timeout',
-            default=.0, type=float,
-            help=('Timeout (in seconds) between the data removes iterations. '
-                  'It used to reduce the database load.')
+            '--timeout',
+            action='store',
+            dest='timeout',
+            default=0.0,
+            type=float,
+            help=('Timeout (in seconds) between the data removes iterations. It used to reduce the database load.'),
         )
         parser.add_argument(
-            '--cursor_itersize', action='store', dest='cursor_itersize',
+            '--cursor_itersize',
+            action='store',
+            dest='cursor_itersize',
             type=int,
             default=None,
-            help='Количество строк загруженных за раз при загрузке строк при работе команды.'
+            help='Количество строк загруженных за раз при загрузке строк при работе команды.',
         )
 
     def handle(self, *args, **options):
+        """Основная логика команды.
+
+        Выполняет проверку модели и поля, затем вызывает функцию очистки
+        записей по условию field_name < before_value.
+        """
         app_label = options['app_label']
         model_name = options['model_name']
         field_name = options['field_name']

educommon/django/db/partitioning/management/commands/split_table.py

@@ -1,6 +1,3 @@
-from django.core.exceptions import (
-    FieldDoesNotExist,
-)
 from django.core.management.base import (
     CommandError,
 )
@@ -29,12 +26,11 @@ class Command(BaseCommand):
     Подробнее см. в `educommon.django.db.partitioning.split_table`.
 
     """
-    help = (
-        'Command moves all the records from database table to partitions of '
-        'this table.'
-    )
+
+    help = 'Command moves all the records from database table to partitions of this table.'
 
     def add_arguments(self, parser):
+        """Добавляет аргументы командной строки для команды переноса данных в разделы."""
         parser.add_argument(
             '--app_label',
             type=str,
@@ -51,19 +47,28 @@ class Command(BaseCommand):
             help='Field name. It will be the partition key.',
         )
         parser.add_argument(
-            '--timeout', action='store', dest='timeout',
-            default=.0, type=float,
-            help=('Timeout (in seconds) between the data transfer iterations. '
-                  'It used to reduce the database load.')
+            '--timeout',
+            action='store',
+            dest='timeout',
+            default=0.0,
+            type=float,
+            help=('Timeout (in seconds) between the data transfer iterations. It used to reduce the database load.'),
         )
         parser.add_argument(
-            '--cursor_itersize', action='store', dest='cursor_itersize',
+            '--cursor_itersize',
+            action='store',
+            dest='cursor_itersize',
             type=int,
             default=None,
-            help='Количество строк загруженных за раз при загрузке строк при работе команды.'
+            help='Количество строк загруженных за раз при загрузке строк при работе команды.',
         )
 
     def handle(self, *args, **options):
+        """Основная логика команды.
+
+        Проверяет наличие модели и заданного поля, затем запускает
+        процесс переноса данных в секции таблицы.
+        """
         app_label = options['app_label']
         model_name = options['model_name']
         field_name = options['field_name']

educommon/django/db/routers.py

@@ -1,4 +1,5 @@
 """Роутеры для приложений Django."""
+
 from abc import (
     ABCMeta,
 )
@@ -43,19 +44,14 @@ class ServiceDbRouterBase(DatabaseRouterBase, metaclass=ABCMeta):
         aliases = list(settings.DATABASES)
         if len(aliases) != 2:
             # Роутер поддерживает только конфигурации с двумя БД.
-            raise ImproperlyConfigured(
-                'Database router support only two databases'
-            )
+            raise ImproperlyConfigured('Database router support only two databases')
 
         self.default_db_alias = DEFAULT_DB_ALIAS
 
         alias_index = 1 if aliases[0] == DEFAULT_DB_ALIAS else 0
         self.service_db_alias = aliases[alias_index]
 
-        self.service_db_model_names = {
-            model_name.lower()
-            for model_name in self.service_db_model_names
-        }
+        self.service_db_model_names = {model_name.lower() for model_name in self.service_db_model_names}
 
     def _db_for_model(self, model, **hints):
         """Возвращает имя БД для чтения/записи данных из модели *model*."""
@@ -71,6 +67,7 @@ class ServiceDbRouterBase(DatabaseRouterBase, metaclass=ABCMeta):
     db_for_write = _db_for_model
 
     def _allow(self, db, app_label, model_name):
+        """Определяет, разрешён ли доступ к модели в указанной БД."""
         assert db in (self.default_db_alias, self.service_db_alias)
 
         if app_label == self.app_name:
@@ -78,12 +75,6 @@ class ServiceDbRouterBase(DatabaseRouterBase, metaclass=ABCMeta):
                 return True
             else:
                 model_name = model_name.lower()
-                return (
-                    (
-                        db == self.default_db_alias and
-                        model_name not in self.service_db_model_names
-                    ) or (
-                        db == self.service_db_alias and
-                        model_name in self.service_db_model_names
-                    )
+                return (db == self.default_db_alias and model_name not in self.service_db_model_names) or (
+                    db == self.service_db_alias and model_name in self.service_db_model_names
                 )

educommon/django/db/signals.py

@@ -1,7 +1,154 @@
+from typing import (
+    Callable,
+    Optional,
+)
+
+from django.db.models import (
+    Model,
+)
 from django.dispatch.dispatcher import (
     Signal,
 )
+from educommon import (
+    logger,
+)
+
+
+class BaseBeforeMigrateHandler:
+    """
+    Базовый обработчик сигнала before_handle_migrate_signal.
+
+    Должен быть унаследован и инстанс наследника регистрироваться
+    как обработчик сигнала.
+    """
+
+    def _is_accessing_non_migrating_databases(self, migrating_database: str) -> bool:
+        for model_cls in self._get_working_models():
+            db = self._get_model_db(model_cls)
+            if db != migrating_database:
+                return True
+
+        return False
+
+    def _get_model_db(self, model_cls: type[Model]) -> str:
+        """
+        Возвращает псевдоним базы данных, к которой пойдет запрос
+        по данной модели.
+        """
+
+        return model_cls.objects.all().db
+
+    def _get_migrating_database(self, sender) -> str:
+        """Возвращает псевдоним базы данных, с которой работает миграция."""
+
+        return sender.database
+
+    def _get_working_models(self) -> set[type[Model]]:
+        """Модели, с которым будет работать обработчик сигнала."""
+
+        raise NotImplementedError()
+
+    def handler(self, sender, *args, **kwargs):
+        """Непосредственный обработчик сигнала."""
+
+        raise NotImplementedError()
+
+    def __call__(self, sender, *args, **kwargs):
+        migrating_database = self._get_migrating_database(sender)
+        if self._is_accessing_non_migrating_databases(migrating_database):
+            logger.debug('Предотвращена попытка доступа к базе данных, по которой не производится миграция')
+            return
+
+        return self.handler(sender, *args, **kwargs)
+
+
+class BaseAfterMigrateHandler:
+    """
+    Базовый обработчик сигнала after_handle_migrate_signal.
+
+    Должен быть унаследован и инстанс наследника регистрироваться
+    как обработчик сигнала.
+    """
+
+    def _is_accessing_non_migrating_databases(self, migrating_database: str) -> bool:
+        for model_cls in self._get_working_models():
+            db = self._get_model_db(model_cls)
+            if db != migrating_database:
+                return True
+
+        return False
+
+    def _get_model_db(self, model_cls: type[Model]) -> str:
+        """
+        Возвращает псевдоним базы данных, к которой пойдет запрос
+        по данной модели.
+        """
+
+        return model_cls.objects.all().db
+
+    def _get_migrating_database(self, sender) -> str:
+        """Возвращает псевдоним базы данных, с которой работает миграция."""
+
+        return sender.database
+
+    def _get_working_models(self) -> set[type[Model]]:
+        """Модели, с которым будет работать обработчик сигнала."""
+
+        raise NotImplementedError()
+
+    def handler(self, sender, *args, **kwargs):
+        """Непосредственный обработчик сигнала."""
+
+        raise NotImplementedError()
+
+    def __call__(self, sender, *args, **kwargs):
+        migrating_database = self._get_migrating_database(sender)
+        if self._is_accessing_non_migrating_databases(migrating_database):
+            logger.debug('Предотвращена попытка доступа к базе данных, по которой не производится миграция')
+            return
+
+        return self.handler(sender, *args, **kwargs)
+
+
+class BeforeHandleMigrateSignal(Signal):
+    _handler_base_class = BaseBeforeMigrateHandler
+
+    def connect(
+        self,
+        receiver: Callable,
+        sender: Optional = None,
+        weak: bool = True,
+        dispatch_uid: Optional[str] = None,
+    ) -> None:
+        """Регистрирует обработчик, если он является допустимым типом."""
+        if not isinstance(receiver, self._handler_base_class):
+            logger.warning(
+                f'Обработчик сигнала before_handle_migrate_signal {receiver} не зарегистрирован, поскольку '
+                f'он не является подклассом {self._handler_base_class.__name__}'
+            )
+
+        return super().connect(receiver, sender, weak, dispatch_uid)
+
+
+class AfterHandleMigrateSignal(Signal):
+    _handler_base_class = BaseBeforeMigrateHandler
+
+    def connect(
+        self,
+        receiver: Callable,
+        sender: Optional = None,
+        weak: bool = True,
+        dispatch_uid: Optional[str] = None,
+    ) -> None:
+        """Регистрирует обработчик, если он является допустимым типом."""
+        if not isinstance(receiver, self._handler_base_class):
+            logger.warning(
+                f'Обработчик сигнала after_handle_migrate_signal {receiver} не зарегистрирован, поскольку '
+                f'он не является подклассом {self._handler_base_class.__name__}'
+            )
+
+        return super().connect(receiver, sender, weak, dispatch_uid)
 
 
-before_handle_migrate_signal = Signal()
-after_handle_migrate_signal = Signal()
+before_handle_migrate_signal = BeforeHandleMigrateSignal()
+after_handle_migrate_signal = AfterHandleMigrateSignal()