"""Модули и импорт: что на самом деле делает `import`.

Времени здесь нет — только наблюдения. Цена первого и повторного импорта —
в cost.py.

Каждый сюжет собирает во временной папке маленькие модули и запускает их в
отдельном интерпретаторе: так у каждого сюжета чистый `sys.modules`, а
`__name__ == "__main__"` проверяется настоящим запуском скрипта. Путь
временной папки в выводе заменён на `<папка>` — иначе запись прогона менялась
бы от запуска к запуску.

ШЕСТЬ СЮЖЕТОВ:

1. МОДУЛЬ ВЫПОЛНЯЕТСЯ ОДИН РАЗ. Повторный `import` берёт готовый объект из
   `sys.modules`; заново тело выполняет только `importlib.reload` — в том же
   объекте модуля, а имена, взятые через from, остаются старыми. Модуль
   попадает в `sys.modules` ещё до выполнения тела.

2. `from m import x` КОПИРУЕТ ССЫЛКУ. Новое присваивание `m.x = …` имени,
   импортированного через from, не видно; изменение изменяемого объекта —
   видно. Отсюда подмена в тестах: до первого импорта она доходит, после —
   нет, а `mock.patch` надо ставить там, где имя ищется.

3. `__name__`. Один и тот же файл, запущенный как скрипт и импортированный.
   И скрипт, который импортирует сам себя: это два разных модуля.

4. ЦИКЛИЧЕСКИЙ ИМПОРТ. `from a import X` из недоимпортированного модуля
   падает; `import a` с обращением `a.X` внутри функции — работает.

5. СВОЙ ФАЙЛ С ИМЕНЕМ МОДУЛЯ СТАНДАРТНОЙ БИБЛИОТЕКИ. `random.py` рядом со
   скриптом заслоняет стандартный `random`.

6. ПАКЕТ. `import pkg.sub` сначала выполняет `pkg/__init__.py`; `import pkg`
   подмодуль сам не загружает. А `json/__init__.py` свои подмодули
   импортирует сам.

Запускать: python3.11 / 3.12 / 3.13 / 3.14.
"""
import os
import subprocess
import sys
import tempfile
import textwrap

print("PY", sys.version.split()[0])
print()


def scene(files, *argv):
    """Создать файлы во временной папке и запустить там интерпретатор."""
    with tempfile.TemporaryDirectory() as tmp:
        tmp = os.path.realpath(tmp)
        for name, body in files.items():
            path = os.path.join(tmp, name)
            os.makedirs(os.path.dirname(path), exist_ok=True)
            with open(path, "w", encoding="utf-8") as f:
                f.write(textwrap.dedent(body))
        env = dict(os.environ, PYTHONDONTWRITEBYTECODE="1")
        env.pop("PYTHONPATH", None)
        r = subprocess.run([sys.executable, *argv], cwd=tmp, env=env, capture_output=True, text=True)
        out = (r.stdout + r.stderr).replace(tmp, "<папка>")
    return out


def show(out, only_last_error=False):
    lines = out.rstrip("\n").split("\n")
    if only_last_error:
        # Из трассировки печатаем строки наших файлов и последнюю — саму ошибку.
        keep = [l for l in lines if not l.startswith((" ", "Traceback"))]
        lines = keep
    for line in lines:
        print("   " + line)


# ── 1 ─────────────────────────────────────────────────────────────────────
print("1) модуль выполняется один раз")
show(scene({
    "noisy.py": """
        import sys
        print("[тело noisy выполняется; noisy уже в sys.modules:", __name__ in sys.modules, "]")
        ITEMS = []
    """,
    "main.py": """
        import importlib
        import sys
        import noisy
        import noisy
        import noisy as again
        print("после трёх import:")
        print("noisy в sys.modules ->", "noisy" in sys.modules)
        print("again is noisy ->", again is noisy)
        print("sys.modules['noisy'] is noisy ->", sys.modules["noisy"] is noisy)
        for _ in range(1000):
            import noisy
        print("ещё 1000 import в цикле — тело не выполнялось")
        from noisy import ITEMS as old_items
        reloaded = importlib.reload(noisy)
        print("после reload — тело выполнилось снова")
        print("reload вернул тот же объект модуля ->", reloaded is noisy)
        print("имя из from до reload is noisy.ITEMS ->", old_items is noisy.ITEMS)
    """,
}, "main.py"))
print()

# ── 2 ─────────────────────────────────────────────────────────────────────
print("2) from m import x копирует ссылку, а не связывает имена")
show(scene({
    "settings.py": """
        DEBUG = False
        ITEMS = []
    """,
    "main.py": """
        import settings
        from settings import DEBUG, ITEMS
        settings.DEBUG = True
        settings.ITEMS.append("x")
        print("settings.DEBUG ->", settings.DEBUG)
        print("DEBUG          ->", DEBUG)
        print("settings.ITEMS ->", settings.ITEMS)
        print("ITEMS          ->", ITEMS)
        print("ITEMS is settings.ITEMS ->", ITEMS is settings.ITEMS)
    """,
}, "main.py"))
patch_files = {
    "settings.py": """
        DEBUG = False
    """,
    "report.py": """
        from settings import DEBUG

        def show():
            return DEBUG
    """,
}
print("   подмена settings.DEBUG = True до первого import report:")
show(scene(patch_files, "-c", "import settings; settings.DEBUG = True; import report; print('report.show() ->', report.show())"))
print("   подмена settings.DEBUG = True после import report:")
show(scene(patch_files, "-c", "import report, settings; settings.DEBUG = True; print('report.show() ->', report.show())"))
print("   mock.patch после import report:")
show(scene(patch_files, "-c", "\n".join([
    "from unittest import mock",
    "import report",
    "with mock.patch('settings.DEBUG', True): print(\"mock.patch('settings.DEBUG') -> report.show() =\", report.show())",
    "with mock.patch('report.DEBUG', True): print(\"mock.patch('report.DEBUG')   -> report.show() =\", report.show())",
])))
print()

# ── 3 ─────────────────────────────────────────────────────────────────────
print("3) __name__: один файл — запуск и импорт")
tool = {
    "tool.py": """
        print("__name__ =", repr(__name__))
        if __name__ == "__main__":
            print("блок if __name__ == '__main__' выполнен")
    """,
}
print("   python tool.py:")
show(scene(tool, "tool.py"))
print("   python -c 'import tool':")
show(scene(tool, "-c", "import tool"))
print("   python -m tool:")
show(scene(tool, "-m", "tool"))
print("   python selfimp.py — скрипт импортирует сам себя:")
show(scene({
    "selfimp.py": """
        print("тело выполняется, __name__ =", repr(__name__))
        COUNTER = []
        if __name__ == "__main__":
            import selfimp
            import sys
            print("selfimp is sys.modules['__main__'] ->", selfimp is sys.modules["__main__"])
    """,
}, "selfimp.py"))
print()

# ── 4 ─────────────────────────────────────────────────────────────────────
# Модули цикла лежат в пакете app/, как в настоящем проекте. Последний
# вариант — те же два файла прямо в папке запуска: на 3.13+ текст ошибки
# там другой (см. README).
print("4) циклический импорт")
print("   app/a: from app.b import Y; app/b: from app.a import X — import app.a:")
show(scene({
    "app/__init__.py": "",
    "app/a.py": """
        from app.b import Y
        X = 1
    """,
    "app/b.py": """
        from app.a import X
        Y = 2
    """,
}, "-c", "import app.a"), only_last_error=True)
print("   app/a: import app.b; app/b: import app.a и app.a.X на уровне модуля:")
show(scene({
    "app/__init__.py": "",
    "app/a.py": """
        import app.b
        X = 1
    """,
    "app/b.py": """
        import app.a
        Y = app.a.X + 1
    """,
}, "-c", "import app.a"), only_last_error=True)
print("   app/a: import app.b; app/b: import app.a и app.a.X внутри функции:")
show(scene({
    "app/__init__.py": "",
    "app/a.py": """
        import app.b
        X = 1
    """,
    "app/b.py": """
        import app.a

        def y():
            return app.a.X + 1
    """,
}, "-c", "import app.a, app.b; print('app.b.y() ->', app.b.y())"))
print("   те же a.py и b.py (from-вариант) прямо в папке запуска — import a:")
show(scene({
    "a.py": """
        from b import Y
        X = 1
    """,
    "b.py": """
        from a import X
        Y = 2
    """,
}, "-c", "import a"), only_last_error=True)
print()

# ── 5 ─────────────────────────────────────────────────────────────────────
print("5) свой random.py рядом со скриптом")
show(scene({
    "random.py": """
        print("[выполняется мой random.py]")
    """,
    "game.py": """
        import random
        print(random.randint(1, 6))
    """,
}, "game.py"), only_last_error=True)
print()

# ── 6 ─────────────────────────────────────────────────────────────────────
print("6) пакет: __init__.py и подмодуль")
pkg = {
    "pkg/__init__.py": """
        print("[pkg/__init__.py]")
    """,
    "pkg/sub.py": """
        print("[pkg/sub.py]")
        NAME = "sub"
    """,
}
print("   import pkg.sub:")
show(scene(pkg, "-c", "import pkg.sub; print('pkg.sub.NAME ->', pkg.sub.NAME)"))
print("   import pkg, затем pkg.sub:")
show(scene(pkg, "-c", "import pkg; print('hasattr(pkg, \"sub\") ->', hasattr(pkg, 'sub')); pkg.sub"), only_last_error=True)
print("   import json — подмодули загрузил json/__init__.py:")
show(scene({}, "-c", "import sys, json; print(\"'json.decoder' in sys.modules ->\", 'json.decoder' in sys.modules); print(\"'json.encoder' in sys.modules ->\", 'json.encoder' in sys.modules)"))
print()

# ── 7 ─────────────────────────────────────────────────────────────────────
# Добавлен по внешнему аудиту урока (14.10.2026). Разделы 1–6 выше не менялись.
#
# ГРАНИЦЫ ПРАВИЛ «МОДУЛЬ — ФАЙЛ .py», «ПАКЕТ — ПАПКА С __init__.py» И «ПОВТОРНО
# ВЫПОЛНЯЕТ ТОЛЬКО reload». Файл .py и папка с __init__.py — типичные случаи,
# а не определение: бывают встроенные модули без файла, модули-расширения на C
# и пакеты-пространства имён без __init__.py. Кеш sys.modules — словарь одного
# интерпретатора: запись можно удалить, и следующий import выполнит модуль
# снова; неудачная первая загрузка в кеше не остаётся; другой процесс
# выполняет модуль заново. И полный пример запуска модуля пакета через -m.
print("7) не только файл .py; границы кеша; python -m пакет.модуль")
print("   встроенный модуль и модуль-расширение:")
show(scene({}, "-c", "\n".join([
    "import sys, _json",
    "print('sys.__spec__.origin ->', repr(sys.__spec__.origin))",
    "print(\"hasattr(sys, '__file__') ->\", hasattr(sys, '__file__'))",
    "print('_json ->', 'встроен в интерпретатор' if _json.__spec__.origin == 'built-in' else 'модуль-расширение, файл .' + _json.__spec__.origin.rsplit('.', 1)[-1])",
])))
print("   пакет без __init__.py (namespace package):")
show(scene({
    "nspkg/mod.py": """
        print("[nspkg/mod.py]")
    """,
}, "-c", "\n".join([
    "import nspkg.mod, nspkg",
    "print('nspkg.__file__ ->', nspkg.__file__)",
    "print('list(nspkg.__path__) ->', list(nspkg.__path__))",
])))
noisy = {
    "noisy.py": """
        print("[тело noisy выполняется]")
    """,
}
print("   del sys.modules['noisy'] и снова import noisy:")
show(scene(noisy, "-c", "\n".join([
    "import sys",
    "import noisy",
    "first = noisy",
    "del sys.modules['noisy']",
    "import noisy",
    "print('новый объект модуля ->', noisy is not first)",
])))
print("   первая загрузка упала — import пробует снова:")
show(scene({
    "flaky.py": """
        import os
        print("[тело flaky выполняется]")
        if not os.path.exists("ready"):
            raise RuntimeError("первая загрузка упала")
    """,
}, "-c", "\n".join([
    "import sys",
    "try:",
    "    import flaky",
    "except RuntimeError as e:",
    "    print('RuntimeError:', e)",
    "print(\"'flaky' in sys.modules ->\", 'flaky' in sys.modules)",
    "open('ready', 'w').close()",
    "import flaky",
    "print(\"'flaky' in sys.modules ->\", 'flaky' in sys.modules)",
])))
print("   другой интерпретатор — свой sys.modules:")
show(scene(noisy, "-c", "\n".join([
    "import subprocess, sys",
    "import noisy",
    "subprocess.run([sys.executable, '-c', 'import noisy'])",
])))
SHOP = {
    "shop/__init__.py": """
        PRICE = 10
    """,
    "shop/cli.py": """
        import sys

        from . import PRICE

        print("__name__ =", repr(__name__))
        print("__package__ =", repr(__package__))
        print("sys.path[0] =", sys.path[0])
        print("PRICE =", PRICE)
    """,
}
print("   python -m shop.cli:")
show(scene(SHOP, "-m", "shop.cli"))
print("   python shop/cli.py:")
show(scene(SHOP, "shop/cli.py"), only_last_error=True)