AreaReinforcement_multi_v2.py

# -*- coding: utf-8 -*-

# ============================================================
# pyRevit
# AREA REINFORCEMENT -> НОВАЯ СТЕНА
#
# Revit 2024
#
# Работа:
# 1. Нажать кнопку pyRevit.
# 2. Выбрать исходное Area Reinforcement.
# 3. Выбрать целевую Wall.
#
# При успехе:
#   никаких сообщений пользователю не выводится.
#
# При ошибке:
#   показывается TaskDialog.
#
# Исходное армирование удаляется ТОЛЬКО после
# успешного создания и проверки нового.
# ============================================================


import clr


# ============================================================
# REVIT API
# ============================================================

clr.AddReference("RevitAPI")
clr.AddReference("RevitAPIUI")

from Autodesk.Revit.DB import *
from Autodesk.Revit.DB.Structure import *
from Autodesk.Revit.UI.Selection import ObjectType


# ============================================================
# DOCUMENT
# ============================================================

uidoc = __revit__.ActiveUIDocument
doc = uidoc.Document


# ============================================================
# TASKDIALOG
# ============================================================

def show_error(message):

    try:
        TaskDialog.Show(
            "Area Reinforcement",
            "Операция не выполнена.\n\n" + str(message)
        )

    except:
        pass


# ============================================================
# ПОЛУЧЕНИЕ ПАРАМЕТРА
# ============================================================

def get_param(element, name):

    try:
        return element.LookupParameter(name)

    except:
        return None


# ============================================================
# ПОЛУЧЕНИЕ STRING
# ============================================================

def get_string(element, name):

    p = get_param(element, name)

    if p is None:
        return None

    try:

        if p.StorageType == StorageType.String:
            return p.AsString()

        return p.AsValueString()

    except:

        return None


# ============================================================
# УСТАНОВКА INTEGER
# ============================================================

def set_integer_parameter(element, name, value):

    p = get_param(element, name)

    if p is None:
        return "NOT_FOUND"

    try:

        if p.IsReadOnly:
            return "READ_ONLY"

    except:

        return "READ_ONLY"

    try:

        p.Set(int(value))

        return "OK"

    except Exception as ex:

        return "ERROR: {}".format(str(ex))


# ============================================================
# КОПИРОВАНИЕ ОДНОГО ПАРАМЕТРА
# ============================================================

def copy_one_parameter(source, target, source_param):

    try:

        name = source_param.Definition.Name

    except:

        return "SKIP"


    # ========================================================
    # СЛУЖЕБНЫЕ ПАРАМЕТРЫ
    # ========================================================

    excluded = [

        "Метка основы",

        "Семейство и типоразмер",
        "Семейство",
        "Тип",
        "Код типа",

        "Категория",
        "Категория основы",

        "Объем арматуры",

        "Сводка по слоям",
        "Сводка по слоям (кратко)",

        "Основное направление, обе грани",
        "Основное направление, обе грани (кратко)",

        "Второстепенное направление, обе грани",
        "Второстепенное направление, обе грани (кратко)",

        "Нижняя/внутренняя грань, основное направление",
        "Нижняя/внутренняя грань, основное направление (кратко)",

        "Нижняя/внутренняя грань, второстепенное направление",
        "Нижняя/внутренняя грань, второстепенное направление (кратко)",

        "Верхняя/наружная грань, основное направление",
        "Верхняя/наружная грань, основное направление (кратко)",

        "Верхняя/наружная грань, второстепенное направление",
        "Верхняя/наружная грань, второстепенное направление (кратко)"
    ]


    if name in excluded:
        return "SKIP"


    # ========================================================
    # ИЩЕМ ПАРАМЕТР У НОВОГО ОБЪЕКТА
    # ========================================================

    target_param = get_param(target, name)

    if target_param is None:
        return "TARGET_NOT_FOUND"


    # ========================================================
    # READ ONLY
    # ========================================================

    try:

        if target_param.IsReadOnly:
            return "READ_ONLY"

    except:

        return "READ_ONLY"


    # ========================================================
    # КОПИРОВАНИЕ
    # ========================================================

    try:

        storage = source_param.StorageType


        # ----------------------------------------------------
        # STRING
        # ----------------------------------------------------

        if storage == StorageType.String:

            value = source_param.AsString()

            if value is None:
                value = ""

            target_param.Set(value)

            return "COPIED"


        # ----------------------------------------------------
        # DOUBLE
        # ----------------------------------------------------

        elif storage == StorageType.Double:

            value = source_param.AsDouble()

            target_param.Set(value)

            return "COPIED"


        # ----------------------------------------------------
        # INTEGER
        # ----------------------------------------------------

        elif storage == StorageType.Integer:

            value = source_param.AsInteger()

            target_param.Set(value)

            return "COPIED"


        # ----------------------------------------------------
        # ELEMENT ID
        # ----------------------------------------------------

        elif storage == StorageType.ElementId:

            value = source_param.AsElementId()

            if value is not None:

                target_param.Set(value)

                return "COPIED"

            return "NO_VALUE"


        return "UNSUPPORTED"


    except Exception as ex:

        return "ERROR: {}".format(str(ex))


# ============================================================
# КОПИРОВАНИЕ ВСЕХ ДОСТУПНЫХ ПАРАМЕТРОВ
# ============================================================

def copy_all_parameters(source, target):

    copied = []
    skipped = []
    errors = []


    for source_param in source.Parameters:

        try:

            name = source_param.Definition.Name

        except:

            continue


        status = copy_one_parameter(
            source,
            target,
            source_param
        )


        if status == "COPIED":

            copied.append(name)


        elif status.startswith("ERROR"):

            errors.append(
                name + " [" + status + "]"
            )


        elif status == "TARGET_NOT_FOUND":

            skipped.append(
                name + " [нет у нового]"
            )


        elif status == "READ_ONLY":

            skipped.append(
                name + " [только чтение]"
            )


        elif status == "SKIP":

            skipped.append(
                name + " [служебный]"
            )


        else:

            skipped.append(
                name + " [" + status + "]"
            )


    return copied, skipped, errors


# ============================================================
# СРАВНЕНИЕ ТОЧЕК
# ============================================================

def points_equal(p1, p2, tolerance):

    return (

        abs(p1.X - p2.X) <= tolerance

        and

        abs(p1.Y - p2.Y) <= tolerance

        and

        abs(p1.Z - p2.Z) <= tolerance

    )


# ============================================================
# ПОЛУЧЕНИЕ И СОРТИРОВКА ГРАНИЦ AREA REINFORCEMENT
#
# Revit может вернуть Boundary Curve IDs
# не в порядке обхода контура.
#
# Для AreaReinforcement.Create()
# кривые должны образовывать непрерывную цепочку.
#
# Геометрия кривых не изменяется.
#
# Меняется только:
#   1. порядок кривых;
#   2. направление отдельных кривых.
# ============================================================

def get_boundary_curves(reinforcement):

    boundary_ids = reinforcement.GetBoundaryCurveIds()

    raw_curves = []


    # ========================================================
    # ПОЛУЧАЕМ ВСЕ ИСХОДНЫЕ КРИВЫЕ
    # ========================================================

    for cid in boundary_ids:

        element = doc.GetElement(cid)

        if element is None:
            continue

        try:

            curve = element.Curve

            if curve is None:
                continue

            raw_curves.append(curve)

        except:

            continue


    if len(raw_curves) < 3:

        raise Exception(
            "Не удалось получить корректный контур."
        )


    tolerance = 0.0001


    # ========================================================
    # СТРОИМ НЕПРЕРЫВНУЮ ЦЕПОЧКУ
    # ========================================================

    remaining = list(raw_curves)

    ordered = []


    # ========================================================
    # ПЕРВАЯ КРИВАЯ
    # ========================================================

    first = remaining.pop(0)

    ordered.append(first)

    current_end = first.GetEndPoint(1)


    # ========================================================
    # ПОИСК СЛЕДУЮЩЕЙ КРИВОЙ
    # ========================================================

    while len(remaining) > 0:

        found_index = -1

        reverse_curve = False


        for i in range(len(remaining)):

            curve = remaining[i]

            p0 = curve.GetEndPoint(0)
            p1 = curve.GetEndPoint(1)


            # ------------------------------------------------
            # Вариант 1:
            #
            # конец предыдущей =
            # начало следующей
            # ------------------------------------------------

            if points_equal(
                current_end,
                p0,
                tolerance
            ):

                found_index = i

                reverse_curve = False

                break


            # ------------------------------------------------
            # Вариант 2:
            #
            # конец предыдущей =
            # конец следующей
            #
            # Кривую нужно развернуть.
            # ------------------------------------------------

            if points_equal(
                current_end,
                p1,
                tolerance
            ):

                found_index = i

                reverse_curve = True

                break


        # ====================================================
        # НИЧЕГО НЕ НАШЛИ
        # ====================================================

        if found_index == -1:

            raise Exception(
                "Не удалось построить непрерывный контур. "
                "Осталось несоединённых кривых: {}".format(
                    len(remaining)
                )
            )


        curve = remaining.pop(found_index)


        # ====================================================
        # РАЗВОРАЧИВАЕМ ПРИ НЕОБХОДИМОСТИ
        # ====================================================

        if reverse_curve:

            try:

                curve = curve.CreateReversed()

            except Exception as ex:

                raise Exception(
                    "Не удалось развернуть кривую "
                    "контура: {}".format(
                        str(ex)
                    )
                )


        ordered.append(curve)

        current_end = curve.GetEndPoint(1)


    # ========================================================
    # ПРОВЕРЯЕМ ЗАМЫКАНИЕ
    # ========================================================

    first_start = ordered[0].GetEndPoint(0)

    last_end = ordered[-1].GetEndPoint(1)


    if not points_equal(
        first_start,
        last_end,
        tolerance
    ):

        raise Exception(
            "Контур не замкнут. "
            "Начальная и конечная точки не совпадают."
        )


    # ========================================================
    # List[Curve]
    # ========================================================

    from System.Collections.Generic import List

    curves = List[Curve]()

    points = []


    for curve in ordered:

        curves.Add(curve)

        points.append(
            curve.GetEndPoint(0)
        )

        points.append(
            curve.GetEndPoint(1)
        )


    return curves, points


# ============================================================
# ПОЛУЧЕНИЕ ГАБАРИТОВ
# ============================================================

def get_xyz_range(points):

    min_x = min(
        p.X for p in points
    )

    max_x = max(
        p.X for p in points
    )

    min_y = min(
        p.Y for p in points
    )

    max_y = max(
        p.Y for p in points
    )

    min_z = min(
        p.Z for p in points
    )

    max_z = max(
        p.Z for p in points
    )


    return (
        min_x,
        max_x,
        min_y,
        max_y,
        min_z,
        max_z
    )


# ============================================================
# ============================================================
# ВЫБОР ELEMENT В REVIT
# ============================================================

def pick_element(message):

    try:

        reference = uidoc.Selection.PickObject(
            ObjectType.Element,
            message
        )

        if reference is None:
            return None

        return doc.GetElement(
            reference.ElementId
        )

    except:

        # Escape / отмена выбора
        return None


def get_selected_area_reinforcements():

    """
    Возвращает AreaReinforcement из текущего выделения Revit.

    Посторонние элементы игнорируются.
    """

    result = []

    try:

        selected_ids = uidoc.Selection.GetElementIds()

        for element_id in selected_ids:

            element = doc.GetElement(element_id)

            if isinstance(
                element,
                AreaReinforcement
            ):

                result.append(element)

    except:

        pass

    return result


def pick_area_reinforcements():

    """
    Ручной множественный выбор.

    Используется стандартный механизм выбора Revit БЕЗ
    ISelectionFilter. Это позволяет пользоваться штатным
    выделением, включая выбор рамкой.

    После завершения выбора оставляем только
    AreaReinforcement.
    """

    try:

        references = uidoc.Selection.PickObjects(
            ObjectType.Element,
            "Выберите армирование по площади "
            "(можно рамкой и Ctrl+кликом). "
            "Нажмите Готово."
        )

        if references is None:
            return []

        result = []

        seen_ids = set()

        for reference in references:

            try:

                element_id = reference.ElementId

                id_value = element_id.IntegerValue

                if id_value in seen_ids:
                    continue

                seen_ids.add(id_value)

                element = doc.GetElement(
                    element_id
                )

                if isinstance(
                    element,
                    AreaReinforcement
                ):

                    result.append(element)

            except:

                pass

        return result

    except:

        # Escape / отмена выбора
        return []


def get_area_reinforcements_for_processing():

    """
    Логика выбора:

    1. Если до запуска кнопки уже выделены
       AreaReinforcement — используем их.
    2. Если подходящих элементов нет — запускаем
       ручной множественный выбор.
    3. При ручном выборе посторонние элементы
       автоматически игнорируются.
    """

    reinforcements = (
        get_selected_area_reinforcements()
    )

    if len(reinforcements) > 0:
        return reinforcements

    return pick_area_reinforcements()


# ============================================================
# ОСНОВНАЯ ПРОЦЕДУРА
# ============================================================
def process_one_reinforcement(rein, wall):

    new_rein = None
    transaction = None
    transaction_started = False

    # ========================================================
    # ИСХОДНЫЕ МЕТКИ
    # ========================================================

    source_mark = get_string(
        rein,
        "Метка основы"
    )

    wall_mark = get_string(
        wall,
        "Марка"
    )


    # ========================================================
    # ЕСЛИ ОСНОВА УЖЕ ПРАВИЛЬНАЯ
    #
    # В этом случае ничего не делаем.
    # ========================================================

    if (

        source_mark is not None

        and

        wall_mark is not None

        and

        source_mark == wall_mark

    ):

        # Успешное завершение без вывода.

        pass


    else:

        # ====================================================
        # ИСХОДНЫЕ СЛОИ
        # ====================================================

        source_bottom_major = False
        source_bottom_minor = False
        source_top_major = False
        source_top_minor = False


        try:

            source_bottom_major = rein.IsLayerActive(
                AreaReinforcementLayerType.BottomOrBackMajor
            )

        except:

            pass


        try:

            source_bottom_minor = rein.IsLayerActive(
                AreaReinforcementLayerType.BottomOrBackMinor
            )

        except:

            pass


        try:

            source_top_major = rein.IsLayerActive(
                AreaReinforcementLayerType.TopOrFrontMajor
            )

        except:

            pass


        try:

            source_top_minor = rein.IsLayerActive(
                AreaReinforcementLayerType.TopOrFrontMinor
            )

        except:

            pass


        # ====================================================
        # ИСХОДНЫЕ НАПРАВЛЕНИЯ
        # ====================================================

        source_bottom_major_dir = 0
        source_bottom_minor_dir = 0
        source_top_major_dir = 0
        source_top_minor_dir = 0


        p = get_param(
            rein,
            "Основное направление, "
            "нижняя/внутренняя грань"
        )


        if p is not None:

            try:

                source_bottom_major_dir = p.AsInteger()

            except:

                pass


        p = get_param(
            rein,
            "Второстепенное направление, "
            "нижняя/внутренняя грань"
        )


        if p is not None:

            try:

                source_bottom_minor_dir = p.AsInteger()

            except:

                pass


        p = get_param(
            rein,
            "Основное направление, "
            "верхняя/наружная грань"
        )


        if p is not None:

            try:

                source_top_major_dir = p.AsInteger()

            except:

                pass


        p = get_param(
            rein,
            "Второстепенное направление, "
            "верхняя/наружная грань"
        )


        if p is not None:

            try:

                source_top_minor_dir = p.AsInteger()

            except:

                pass


        # ====================================================
        # TYPE
        # ====================================================

        area_type_id = rein.GetTypeId()

        major_direction = rein.Direction


        # ====================================================
        # REBAR TYPE
        # ====================================================

        ris_ids = rein.GetRebarInSystemIds()


        if len(ris_ids) == 0:

            raise Exception(
                "У исходного Area Reinforcement "
                "не найден RebarInSystem."
            )


        source_ris = doc.GetElement(
            ris_ids[0]
        )


        if source_ris is None:

            raise Exception(
                "Не удалось получить исходный "
                "RebarInSystem."
            )


        rebar_type_id = source_ris.GetTypeId()


        # ====================================================
        # ИСХОДНЫЙ КОНТУР
        # ====================================================

        curves, source_points = (
            get_boundary_curves(rein)
        )


        (
            min_x,
            max_x,
            min_y,
            max_y,
            min_z,
            max_z
        ) = get_xyz_range(
            source_points
        )


        # ====================================================
        # TRANSACTION
        # ====================================================

        from Autodesk.Revit.DB import Transaction

        transaction = Transaction(
            doc,
            "Перенос Area Reinforcement"
        )


        transaction.Start()

        transaction_started = True


        try:

            # ================================================
            # СОЗДАНИЕ НОВОГО AREA REINFORCEMENT
            #
            # Исходные кривые используются без изменения
            # размеров и геометрии.
            #
            # Меняется только порядок и направление кривых.
            # ================================================

            new_rein = AreaReinforcement.Create(
                doc,
                wall,
                curves,
                major_direction,
                area_type_id,
                rebar_type_id,
                ElementId.InvalidElementId
            )


            if new_rein is None:

                raise Exception(
                    "AreaReinforcement.Create "
                    "вернул None."
                )


            # ================================================
            # КОПИРОВАНИЕ ПАРАМЕТРОВ
            # ================================================

            copied, skipped, errors = (
                copy_all_parameters(
                    rein,
                    new_rein
                )
            )


            # ================================================
            # ВОССТАНОВЛЕНИЕ ИСХОДНЫХ СЛОЁВ
            # ================================================

            try:

                new_rein.SetLayerActive(
                    AreaReinforcementLayerType.BottomOrBackMajor,
                    source_bottom_major
                )

            except:

                pass


            try:

                new_rein.SetLayerActive(
                    AreaReinforcementLayerType.BottomOrBackMinor,
                    source_bottom_minor
                )

            except:

                pass


            try:

                new_rein.SetLayerActive(
                    AreaReinforcementLayerType.TopOrFrontMajor,
                    source_top_major
                )

            except:

                pass


            try:

                new_rein.SetLayerActive(
                    AreaReinforcementLayerType.TopOrFrontMinor,
                    source_top_minor
                )

            except:

                pass


            # ================================================
            # ВОССТАНОВЛЕНИЕ НАПРАВЛЕНИЙ
            # ================================================

            r1 = set_integer_parameter(
                new_rein,
                "Основное направление, "
                "нижняя/внутренняя грань",
                source_bottom_major_dir
            )


            r2 = set_integer_parameter(
                new_rein,
                "Второстепенное направление, "
                "нижняя/внутренняя грань",
                source_bottom_minor_dir
            )


            r3 = set_integer_parameter(
                new_rein,
                "Основное направление, "
                "верхняя/наружная грань",
                source_top_major_dir
            )


            r4 = set_integer_parameter(
                new_rein,
                "Второстепенное направление, "
                "верхняя/наружная грань",
                source_top_minor_dir
            )


            # ================================================
            # REGENERATE
            # ================================================

            doc.Regenerate()


            # ================================================
            # ПРОВЕРКА ОСНОВЫ
            #
            # AreaReinforcement.Create автоматически
            # определяет выбранную Wall как основу.
            # ================================================

            new_mark = get_string(
                new_rein,
                "Метка основы"
            )


            if (

                new_mark is None

                or

                wall_mark is None

                or

                new_mark != wall_mark

            ):

                raise Exception(
                    "Новая Area Reinforcement "
                    "получила неправильную основу."
                )


            # ================================================
            # ПРОВЕРКА REBAR
            # ================================================

            new_ris_ids = (
                new_rein.GetRebarInSystemIds()
            )


            if len(new_ris_ids) == 0:

                raise Exception(
                    "В новой Area Reinforcement "
                    "нет RebarInSystem."
                )


            # ================================================
            # ПРОВЕРКА КОНТУРА
            # ================================================

            new_curves, new_points = (
                get_boundary_curves(new_rein)
            )


            (
                new_min_x,
                new_max_x,
                new_min_y,
                new_max_y,
                new_min_z,
                new_max_z
            ) = get_xyz_range(
                new_points
            )


            tolerance = 0.0001


            # ================================================
            # ПРОВЕРКА РАЗМЕРОВ
            # ================================================

            if (

                abs(min_x - new_min_x) > tolerance

                or

                abs(max_x - new_max_x) > tolerance

                or

                abs(min_y - new_min_y) > tolerance

                or

                abs(max_y - new_max_y) > tolerance

                or

                abs(min_z - new_min_z) > tolerance

                or

                abs(max_z - new_max_z) > tolerance

            ):

                raise Exception(
                    "Размер нового контура "
                    "отличается от исходного."
                )


            # ================================================
            # ПРОВЕРКА РАЗДЕЛА
            #
            # Это информационная проверка.
            # Сам параметр уже был скопирован выше.
            # ================================================

            source_section = get_string(
                rein,
                "Раздел"
            )

            new_section = get_string(
                new_rein,
                "Раздел"
            )


            # ================================================
            # ПРОВЕРКА СМЕЩЕНИЙ
            #
            # Значения параметров уже скопированы.
            # Здесь дополнительного изменения нет.
            # ================================================

            # ================================================
            # ВСЕ ПРОВЕРКИ ПРОЙДЕНЫ
            #
            # ТОЛЬКО ТЕПЕРЬ УДАЛЯЕМ ИСХОДНЫЙ ОБЪЕКТ.
            # ================================================

            old_id = rein.Id


            doc.Delete(old_id)


            # ================================================
            # REGENERATE
            # ================================================

            doc.Regenerate()


            # ================================================
            # ФИКСИРУЕМ TRANSACTION
            # ================================================

            transaction.Commit()

            transaction_started = False


        except Exception as ex:

            # =================================================
            # ОШИБКА ВНУТРИ TRANSACTION
            # =================================================

            try:

                # ---------------------------------------------
                # Если новая Area Reinforcement была создана,
                # удаляем её.
                #
                # Исходная при этом остаётся.
                # ---------------------------------------------

                if new_rein is not None:

                    try:

                        doc.Delete(
                            new_rein.Id
                        )

                    except:

                        pass


                transaction.RollBack()

                transaction_started = False


            except:

                # Если RollBack по какой-либо причине
                # недоступен — пробуем закрыть transaction.

                try:

                    transaction.RollBack()

                except:

                    pass


            raise ex




    return "OK"


# ============================================================
try:

    # ========================================================
    # ВЫБОР ИСХОДНЫХ AREA REINFORCEMENT
    # ========================================================
    #
    # Сначала проверяем уже существующее выделение Revit.
    #
    # Если AreaReinforcement там есть — используем его.
    #
    # Если нет — запускаем стандартный множественный
    # выбор Revit. В этом режиме можно выбирать рамкой
    # и отдельными кликами.
    #
    # Посторонние элементы после выбора игнорируются.
    # ========================================================

    reinforcements = (
        get_area_reinforcements_for_processing()
    )

    if reinforcements is None or len(reinforcements) == 0:

        raise Exception(
            "Не выбрано ни одного "
            "Area Reinforcement."
        )


    # ========================================================
    # ВЫБОР ОДНОЙ ЦЕЛЕВОЙ СТЕНЫ
    # ========================================================

    wall = pick_element(
        "Выберите ЦЕЛЕВУЮ СТЕНУ"
    )

    if wall is None:

        raise Exception(
            "Целевая стена не выбрана."
        )


    if not isinstance(
        wall,
        Wall
    ):

        raise Exception(
            "Выбранный элемент не является стеной."
        )


    # ========================================================
    # ПОСЛЕДОВАТЕЛЬНАЯ ОБРАБОТКА
    # ========================================================
    #
    # Каждый Area Reinforcement обрабатывается отдельно.
    #
    # У каждого своя Transaction.
    #
    # Ошибка одного элемента НЕ откатывает уже успешно
    # обработанные элементы.
    # ========================================================

    errors = []

    success_count = 0

    for index, rein in enumerate(
        reinforcements
    ):

        try:

            process_one_reinforcement(
                rein,
                wall
            )

            success_count += 1

        except Exception as ex:

            try:
                rein_id = rein.Id.IntegerValue
            except:
                rein_id = "?"

            errors.append(
                "{}. ElementId {}: {}".format(
                    index + 1,
                    rein_id,
                    str(ex)
                )
            )


    # ========================================================
    # ИТОГ
    # ========================================================
    #
    # При полном успехе никаких сообщений нет.
    #
    # Если были ошибки — показываем только их.
    #
    # Успешно обработанные элементы уже зафиксированы.
    # ========================================================

    if len(errors) > 0:

        try:

            TaskDialog.Show(
                "Area Reinforcement",
                "Обработка завершена с ошибками.\n\n"
                "Выбрано: {}\n"
                "Успешно обработано: {}\n"
                "Ошибок: {}\n\n{}"
                .format(
                    len(reinforcements),
                    success_count,
                    len(errors),
                    "\n\n".join(errors)
                )
            )

        except:

            pass


except Exception as ex:

    # ========================================================
    # ГЛОБАЛЬНАЯ ОШИБКА
    # ========================================================

    show_error(
        str(ex)
    )


# ============================================================
# КОНЕЦ
# ============================================================