{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Мини-проект: заказ с проверками\n",
    "\n",
    "OrderLine и Order на dataclass, проверки в __post_init__, своя иерархия исключений, разбор строк заказа с raise … from и касса, которая перехватывает ошибки и пишет понятный отчёт.\n",
    "\n",
    "Курс ООП в Python · урок `oop-p8-order` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/p8-order).\n",
    "\n",
    "Выполняйте ячейки по порядку (Shift+Enter), начиная с первой — она готовит урок. После каждого упражнения идёт\n",
    "ячейка проверки: она печатает ✓ / ✗ и итог."
   ],
   "id": "intro"
  },
  {
   "cell_type": "code",
   "metadata": {
    "cellView": "form",
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "# @title Подготовка урока — выполните эту ячейку первой\n",
    "# Проверяет версии пакетов, записывает файлы данных в папку data/ и определяет _check — проверку упражнений.\n",
    "import base64, os, zlib\n",
    "\n",
    "import sys\n",
    "\n",
    "if sys.version_info < (3, 10):\n",
    "    print(f\"Урок написан для Python 3.10 и новее, у вас {sys.version.split()[0]} — часть кода может не работать\")\n",
    "\n",
    "# ─── Проверка упражнений: тот же раннер, что у задач на сайте ───\n",
    "# ─── Запуск тестов ───────────────────────────────────────────────────────────\n",
    "\n",
    "_TIMEOUT = 2.0  # секунд на тест; отдельный тест может задать свой: test_x.timeout = 10\n",
    "\n",
    "\n",
    "def _call_with_timeout(target, seconds: float) -> bool:\n",
    "    \"\"\"Запускает target() в отдельном потоке. Возвращает False, если за seconds он не завершился.\"\"\"\n",
    "    import sys\n",
    "    import threading\n",
    "\n",
    "    if sys.platform == \"emscripten\":  # Python в браузере: потоков нет, таймаут обеспечивает страница\n",
    "        target()\n",
    "        return True\n",
    "    # Большой стек нужен, чтобы глубокая рекурсия давала RecursionError, а не аварийное завершение Python.\n",
    "    for megabytes in (256, 64, 0):\n",
    "        try:\n",
    "            threading.stack_size(megabytes * 1024 * 1024)\n",
    "            worker = threading.Thread(target=target, daemon=True)\n",
    "            worker.start()\n",
    "        except (ValueError, RuntimeError, MemoryError):\n",
    "            continue\n",
    "        worker.join(seconds)\n",
    "        return not worker.is_alive()\n",
    "    target()  # потоки недоступны — запускаем без таймаута\n",
    "    return True\n",
    "\n",
    "\n",
    "def _test_info(fn) -> dict:\n",
    "    \"\"\"Описание теста, его лимит времени и сообщение на случай зависания.\"\"\"\n",
    "    limit = getattr(fn, \"timeout\", _TIMEOUT)\n",
    "    hint = getattr(fn, \"timeout_hint\", \"\")\n",
    "    message = (\n",
    "        f\"тест не завершился за {limit:g} с — возможно, бесконечный цикл или рекурсия: \"\n",
    "        \"проверьте, что границы/аргументы изменяются на каждом шаге\" + (f\". {hint}\" if hint else \"\")\n",
    "    )\n",
    "    return {\"title\": (fn.__doc__ or fn.__name__).strip(), \"timeout\": limit, \"timeout_message\": message}\n",
    "\n",
    "\n",
    "def _error_result(title: str, error: BaseException, user_file: str | None) -> dict:\n",
    "    \"\"\"Результат упавшего теста: статус, сообщение, тип исключения и строка в коде решения.\"\"\"\n",
    "    line = None\n",
    "    if user_file:  # самый глубокий кадр в коде решения; ошибка внутри самих тестов — без номера строки\n",
    "        tb = error.__traceback__\n",
    "        while tb is not None:\n",
    "            if tb.tb_frame.f_code.co_filename == user_file:\n",
    "                line = tb.tb_lineno\n",
    "            tb = tb.tb_next\n",
    "    status, message = \"error\", f\"{type(error).__name__}: {error}\"\n",
    "    if isinstance(error, NotImplementedError):\n",
    "        status, message, line = \"not_written\", \"функция ещё не написана\", None\n",
    "    elif isinstance(error, AssertionError):\n",
    "        status, message = \"failed\", str(error) or \"проверка не прошла\"\n",
    "    elif isinstance(error, RecursionError):\n",
    "        message = \"RecursionError: слишком глубокая рекурсия — проверьте базовый случай и то, что задача уменьшается\"\n",
    "    elif isinstance(error, MemoryError) or (isinstance(error, OverflowError) and \"index-sized\" in str(error)):\n",
    "        message = f\"{type(error).__name__}: не хватило памяти — возможно, создаётся слишком большая структура данных\"\n",
    "    return {\"title\": title, \"status\": status, \"message\": message, \"error_type\": type(error).__name__, \"line\": line}\n",
    "\n",
    "\n",
    "def _run_tests(verbose: bool = True, on_start=None, on_result=None, user_file: str | None = None) -> list[dict]:\n",
    "    \"\"\"Запускает тесты задачи (_TESTS — функции из tests.py) по порядку, каждый — с таймаутом.\n",
    "\n",
    "    Возвращает список результатов: {\"title\", \"status\", \"message\", \"error_type\", \"line\"}, где status —\n",
    "    passed · failed · error · not_written · timeout · not_run. Если тест завис, при verbose=True печатает\n",
    "    итог и завершает процесс: зависший поток остановить нельзя. on_start(i) и on_result(i, результат)\n",
    "    вызываются по мере выполнения; user_file — имя файла с кодом решения для номеров строк в ошибках.\n",
    "    \"\"\"\n",
    "    import os\n",
    "    import sys\n",
    "\n",
    "    if verbose:\n",
    "        try:  # ✓ и кириллица в консоли Windows со старой кодировкой\n",
    "            sys.stdout.reconfigure(encoding=\"utf-8\")\n",
    "        except Exception:  # noqa: BLE001 — reconfigure может не быть (перенаправленный вывод, браузер)\n",
    "            pass\n",
    "\n",
    "    tests = list(_TESTS)\n",
    "    results: list[dict] = []\n",
    "    not_written = hung = False\n",
    "    for index, fn in enumerate(tests):\n",
    "        info = _test_info(fn)\n",
    "        outcome: dict = {}\n",
    "\n",
    "        def target(fn=fn, outcome=outcome):\n",
    "            try:\n",
    "                fn()\n",
    "            except BaseException as e:\n",
    "                outcome[\"error\"] = e\n",
    "\n",
    "        if on_start:\n",
    "            on_start(index)\n",
    "        if not _call_with_timeout(target, info[\"timeout\"]):\n",
    "            results.append({\"title\": info[\"title\"], \"status\": \"timeout\", \"message\": info[\"timeout_message\"], \"error_type\": None, \"line\": None})\n",
    "            for other in tests[index + 1:]:\n",
    "                results.append({\"title\": _test_info(other)[\"title\"], \"status\": \"not_run\", \"message\": \"не запускался: предыдущий тест завис\", \"error_type\": None, \"line\": None})\n",
    "            hung = True\n",
    "            break\n",
    "        error = outcome.get(\"error\")\n",
    "        if error is None:\n",
    "            result = {\"title\": info[\"title\"], \"status\": \"passed\", \"message\": \"\", \"error_type\": None, \"line\": None}\n",
    "        else:\n",
    "            result = _error_result(info[\"title\"], error, user_file)\n",
    "            not_written = not_written or result[\"status\"] == \"not_written\"\n",
    "        results.append(result)\n",
    "        if on_result:\n",
    "            on_result(index, result)\n",
    "\n",
    "    if not_written:  # пока функция не написана, «даром» пройденные тесты не засчитываются\n",
    "        for r in results:\n",
    "            if r[\"status\"] == \"passed\":\n",
    "                r.update(status=\"not_written\", message=\"не засчитан, пока функция не написана\")\n",
    "    for r in results:\n",
    "        if len(r[\"message\"]) > 300:\n",
    "            r[\"message\"] = r[\"message\"][:300] + \"…\"\n",
    "\n",
    "    if verbose:\n",
    "        if not_written:\n",
    "            print(\"Функция ещё не написана — замените raise NotImplementedError своим кодом.\\n\")\n",
    "        for r in results:\n",
    "            mark = {\"passed\": \"✓\", \"not_run\": \"–\"}.get(r[\"status\"], \"✗\")\n",
    "            print(f\"{mark} {r['title']}\")\n",
    "            if r[\"message\"]:\n",
    "                print(f\"    {r['message']}\")\n",
    "        passed = sum(r[\"status\"] == \"passed\" for r in results)\n",
    "        print(\"─\" * 40)\n",
    "        print(f\"Прошло {passed} из {len(results)}\" + (\" — всё верно!\" if passed == len(results) else \"\"))\n",
    "        if hung:\n",
    "            print(\"Выполнение остановлено: один из тестов завис.\")\n",
    "            sys.stdout.flush()\n",
    "            os._exit(1)\n",
    "    return results\n",
    "\n",
    "\n",
    "def _check(*tests, names=()):\n",
    "    \"\"\"Запускает проверки упражнения и печатает ✓ / ✗ и итог — как на сайте.\"\"\"\n",
    "    for name in names:\n",
    "        if \".\" in name:  # «Класс.метод» из заготовки: класс должен быть объявлен\n",
    "            if not isinstance(globals().get(name.split(\".\")[0]), type):\n",
    "                print(f\"✗ класс {name.split('.')[0]} не объявлен — выполните ячейку упражнения\")\n",
    "                return\n",
    "            continue\n",
    "        if name not in globals():\n",
    "            print(f\"✗ переменная {name} не создана — выполните ячейку упражнения\")\n",
    "            return\n",
    "        if globals()[name] is Ellipsis:\n",
    "            print(f\"✗ {name} пока равна ... — замените многоточие своим кодом\")\n",
    "            return\n",
    "    globals()[\"_TESTS\"] = list(tests)\n",
    "    _run_tests()"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "setup"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Заказы приходят в кассу «Кофейной лавки» строками вида `\"Латте;220;2\"` — название, цена, количество. Строки\n",
    "пишут люди, и в них бывают ошибки: отрицательная цена, буква вместо числа, пустой заказ. Касса не должна\n",
    "падать из-за одной плохой строки — она должна провести хорошие заказы и объяснить, что не так с остальными.\n",
    "В проекте собран весь модуль: dataclass, `__post_init__`, `frozen=True`, `field(default_factory=list)` и свои\n",
    "исключения.\n",
    "\n",
    "## Шаг 1. Ошибки заказа"
   ],
   "id": "text-10"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Иерархия исключений\n",
    "\n",
    "Объявите `ShopError` — базовое исключение кассы (подкласс `Exception`) — и два его подкласса:\n",
    "`InvalidLineError` (строка заказа неверна) и `EmptyOrderError` (в заказе нет ни одной строки).\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Три класса с телом `pass`; важны базовые классы в скобках.\n",
    "\n",
    "</details>"
   ],
   "id": "errors-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# объявите ShopError, InvalidLineError и EmptyOrderError"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "errors"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def _cls(name):\n",
    "    cls = globals().get(name)\n",
    "    assert isinstance(cls, type), f\"класса {name} нет — объявите его\"\n",
    "    return cls\n",
    "\n",
    "\n",
    "def test_hierarchy():\n",
    "    \"ShopError → InvalidLineError, EmptyOrderError\"\n",
    "    shop = _cls(\"ShopError\")\n",
    "    assert issubclass(shop, Exception), \"ShopError должен наследовать от Exception\"\n",
    "    for name in [\"InvalidLineError\", \"EmptyOrderError\"]:\n",
    "        assert issubclass(_cls(name), shop), f\"{name} должен наследовать от ShopError\"\n",
    "\n",
    "_check(test_hierarchy)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "errors-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class ShopError(Exception):\n",
    "    pass\n",
    "\n",
    "\n",
    "class InvalidLineError(ShopError):\n",
    "    pass\n",
    "\n",
    "\n",
    "class EmptyOrderError(ShopError):\n",
    "    pass\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "errors-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 2. Строка заказа"
   ],
   "id": "text-25"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. OrderLine\n",
    "\n",
    "Объявите неизменяемый dataclass `OrderLine` с полями `product` (строка), `price` (целое) и `qty` (целое, по\n",
    "умолчанию 1) и свойством `cost` — цена на количество. Если цена или количество не больше нуля, создание\n",
    "выбрасывает `InvalidLineError` с текстом `\"неверная строка: Чай, цена -120, количество 1\"`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`@dataclass(frozen=True)`; проверка — в `__post_init__`.\n",
    "\n",
    "</details>"
   ],
   "id": "line-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "from dataclasses import dataclass, field\n",
    "\n",
    "\n",
    "class OrderLine:\n",
    "    ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "line"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "from dataclasses import fields, is_dataclass\n",
    "\n",
    "\n",
    "def test_fields():\n",
    "    \"dataclass, frozen, поля\"\n",
    "    assert is_dataclass(OrderLine), \"OrderLine — не dataclass\"\n",
    "    assert [f.name for f in fields(OrderLine)] == [\"product\", \"price\", \"qty\"], f\"поля: {[f.name for f in fields(OrderLine)]}\"\n",
    "    line = OrderLine(\"Латте\", 220)\n",
    "    assert line.qty == 1, \"qty по умолчанию — 1\"\n",
    "    try:\n",
    "        line.price = 1\n",
    "    except AttributeError:\n",
    "        pass\n",
    "    else:\n",
    "        assert False, \"поле price удалось изменить — нужен @dataclass(frozen=True)\"\n",
    "\n",
    "\n",
    "def test_cost():\n",
    "    \"cost — цена на количество\"\n",
    "    assert isinstance(OrderLine.__dict__.get(\"cost\"), property), \"cost должен быть свойством\"\n",
    "    assert OrderLine(\"Латте\", 220, 2).cost == 440, \"у двух латте по 220 ₽ cost — 440\"\n",
    "\n",
    "\n",
    "def test_invalid():\n",
    "    \"неверная цена или количество — InvalidLineError\"\n",
    "    for args in [(\"Чай\", -120, 1), (\"Чай\", 120, 0)]:\n",
    "        try:\n",
    "            OrderLine(*args)\n",
    "        except InvalidLineError as e:\n",
    "            expected = f\"неверная строка: {args[0]}, цена {args[1]}, количество {args[2]}\"\n",
    "            assert str(e) == expected, f\"сообщение {str(e)!r}, а нужно {expected!r}\"\n",
    "        except ValueError:\n",
    "            assert False, \"выброшен ValueError, а нужен InvalidLineError из шага 1\"\n",
    "        else:\n",
    "            assert False, f\"OrderLine{args} создалась — проверьте цену и количество в __post_init__\"\n",
    "\n",
    "_check(test_fields, test_cost, test_invalid)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "line-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "from dataclasses import dataclass, field\n",
    "\n",
    "\n",
    "@dataclass(frozen=True)\n",
    "class OrderLine:\n",
    "    product: str\n",
    "    price: int\n",
    "    qty: int = 1\n",
    "\n",
    "    def __post_init__(self):\n",
    "        if self.price <= 0 or self.qty <= 0:\n",
    "            raise InvalidLineError(f\"неверная строка: {self.product}, цена {self.price}, количество {self.qty}\")\n",
    "\n",
    "    @property\n",
    "    def cost(self):\n",
    "        return self.price * self.qty\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "line-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 3. Заказ"
   ],
   "id": "text-35"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Order\n",
    "\n",
    "Объявите dataclass `Order` с полями `number` (целое) и `lines` — список строк заказа, у каждого заказа свой,\n",
    "по умолчанию пустой. Метод `add(line)` добавляет строку, свойство `total` — сумма `cost` всех строк. Метод\n",
    "`close()` возвращает `total`, а если строк нет — выбрасывает `EmptyOrderError(\"заказ №18 пуст\")` (с номером\n",
    "этого заказа).\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`lines: list = field(default_factory=list)`.\n",
    "\n",
    "</details>"
   ],
   "id": "order-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class Order:\n",
    "    ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "order"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "from dataclasses import fields, is_dataclass\n",
    "\n",
    "\n",
    "def test_fields():\n",
    "    \"dataclass с number и своим списком lines\"\n",
    "    assert is_dataclass(Order), \"Order — не dataclass\"\n",
    "    a, b = Order(17), Order(18)\n",
    "    assert a.lines == [] and b.lines == [], \"у нового заказа lines — пустой список\"\n",
    "    a.lines.append(\"x\")\n",
    "    assert b.lines == [], \"строка одного заказа появилась в другом — нужен field(default_factory=list)\"\n",
    "\n",
    "\n",
    "def test_total():\n",
    "    \"add и total\"\n",
    "    order = Order(17)\n",
    "    order.add(OrderLine(\"Латте\", 220, 2))\n",
    "    order.add(OrderLine(\"Круассан\", 140))\n",
    "    assert isinstance(Order.__dict__.get(\"total\"), property), \"total должен быть свойством\"\n",
    "    assert order.total == 580, f\"total = {order.total!r}, а нужно 580\"\n",
    "    assert order.close() == 580, \"close() возвращает сумму заказа\"\n",
    "\n",
    "\n",
    "def test_empty():\n",
    "    \"пустой заказ — EmptyOrderError\"\n",
    "    try:\n",
    "        Order(18).close()\n",
    "    except EmptyOrderError as e:\n",
    "        assert str(e) == \"заказ №18 пуст\", f\"сообщение {str(e)!r}, а нужно \\\"заказ №18 пуст\\\"\"\n",
    "    else:\n",
    "        assert False, \"close() пустого заказа не выбросил EmptyOrderError\"\n",
    "\n",
    "_check(test_fields, test_total, test_empty)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "order-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "@dataclass\n",
    "class Order:\n",
    "    number: int\n",
    "    lines: list = field(default_factory=list)\n",
    "\n",
    "    def add(self, line):\n",
    "        self.lines.append(line)\n",
    "\n",
    "    @property\n",
    "    def total(self):\n",
    "        return sum(line.cost for line in self.lines)\n",
    "\n",
    "    def close(self):\n",
    "        if not self.lines:\n",
    "            raise EmptyOrderError(f\"заказ №{self.number} пуст\")\n",
    "        return self.total\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "order-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 4. Разбор строки"
   ],
   "id": "text-46"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 4. Строка → OrderLine\n",
    "\n",
    "Напишите функцию `parse_line(text)`: из `\"Латте;220;2\"` она делает `OrderLine(\"Латте\", 220, 2)`. Если частей не\n",
    "три или цена и количество не разбираются в целые числа — `InvalidLineError(\"не разобрать строку: <текст>\")`,\n",
    "а при ошибке `int` — с исходным `ValueError` в качестве причины (`raise … from`). Ошибки самой `OrderLine`\n",
    "(отрицательная цена) пусть уходят дальше как есть.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "`parts = text.split(\";\")`; если `len(parts) != 3` — сразу `raise`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`int(...)` — внутри `try`, `OrderLine(...)` — уже после него, чтобы её `InvalidLineError` не превратилась в «не разобрать строку».\n",
    "\n",
    "</details>"
   ],
   "id": "parse-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "def parse_line(text):\n",
    "    ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "parse"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 4 — выполните после своего решения\n",
    "def _error(text):\n",
    "    try:\n",
    "        parse_line(text)\n",
    "    except InvalidLineError as e:\n",
    "        return e\n",
    "    except ValueError as e:\n",
    "        assert False, f\"parse_line({text!r}) выбросил {type(e).__name__}, а нужен InvalidLineError\"\n",
    "    return None\n",
    "\n",
    "\n",
    "def test_ok():\n",
    "    \"правильная строка\"\n",
    "    got = parse_line(\"Латте;220;2\")\n",
    "    assert got == OrderLine(\"Латте\", 220, 2), f\"parse_line(\\\"Латте;220;2\\\") = {got!r}\"\n",
    "\n",
    "\n",
    "def test_bad_format():\n",
    "    \"не три части или не число\"\n",
    "    e = _error(\"Латте;220\")\n",
    "    assert e is not None and str(e) == \"не разобрать строку: Латте;220\", \"для строки из двух частей нужен InvalidLineError(\\\"не разобрать строку: Латте;220\\\")\"\n",
    "    e = _error(\"Какао;190;x2\")\n",
    "    assert e is not None, \"parse_line(\\\"Какао;190;x2\\\") не выбросил InvalidLineError\"\n",
    "    assert str(e) == \"не разобрать строку: Какао;190;x2\", f\"сообщение {str(e)!r}\"\n",
    "    assert isinstance(e.__cause__, ValueError), \"причина ошибки int потеряна — выбрасывайте через raise … from err\"\n",
    "\n",
    "\n",
    "def test_line_error():\n",
    "    \"ошибки OrderLine уходят как есть\"\n",
    "    e = _error(\"Чай;-120;1\")\n",
    "    assert e is not None, \"parse_line(\\\"Чай;-120;1\\\") не выбросил InvalidLineError\"\n",
    "    assert str(e) == \"неверная строка: Чай, цена -120, количество 1\", f\"сообщение {str(e)!r} — OrderLine создавайте вне try, чтобы её ошибка не превращалась в «не разобрать строку»\"\n",
    "\n",
    "_check(test_ok, test_bad_format, test_line_error)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "parse-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "def parse_line(text):\n",
    "    parts = text.split(\";\")\n",
    "    if len(parts) != 3:\n",
    "        raise InvalidLineError(f\"не разобрать строку: {text}\")\n",
    "    name, price, qty = parts\n",
    "    try:\n",
    "        price, qty = int(price), int(qty)\n",
    "    except ValueError as err:\n",
    "        raise InvalidLineError(f\"не разобрать строку: {text}\") from err\n",
    "    return OrderLine(name, price, qty)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "parse-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Шаг 5. Касса за день"
   ],
   "id": "text-58"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 5. Отчёт кассы\n",
    "\n",
    "В словаре `day` — номера заказов и их строки. Для каждого заказа по порядку: создайте `Order`, разберите и\n",
    "добавьте строки, закройте заказ. Сохраните в `results` по строке на заказ: `\"№17: 580 ₽\"` для закрытого и\n",
    "`\"№18: ошибка — заказ №18 пуст\"` для заказа, на котором выброшено исключение кассы (текст — `str` исключения).\n",
    "Перехватывайте только `ShopError` — другие ошибки пусть видны.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Весь заказ — внутри одного `try`: первая же ошибка прекращает работу с ним.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`except ShopError as error:` и `f\"№{number}: ошибка — {error}\"`.\n",
    "\n",
    "</details>"
   ],
   "id": "day-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "day = {\n",
    "    17: [\"Латте;220;2\", \"Круассан;140;1\"],\n",
    "    18: [],\n",
    "    19: [\"Раф;260;1\", \"Чай;-120;1\"],\n",
    "    20: [\"Какао;190;x2\"],\n",
    "    21: [\"Эспрессо;150;3\"],\n",
    "}\n",
    "results = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "day"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 5 — выполните после своего решения\n",
    "def test_results():\n",
    "    \"results — по строке на заказ\"\n",
    "    assert isinstance(results, list), f\"results — это {type(results).__name__}, а нужен список строк\"\n",
    "    assert len(results) == 5, f\"в results {len(results)} строк, а заказов 5 — по одной строке на заказ, даже если в нём ошибка\"\n",
    "    expected = [\n",
    "        \"№17: 580 ₽\",\n",
    "        \"№18: ошибка — заказ №18 пуст\",\n",
    "        \"№19: ошибка — неверная строка: Чай, цена -120, количество 1\",\n",
    "        \"№20: ошибка — не разобрать строку: Какао;190;x2\",\n",
    "        \"№21: 450 ₽\",\n",
    "    ]\n",
    "    for got, want in zip(results, expected):\n",
    "        assert got == want, f\"строка отчёта {got!r}, а нужно {want!r}\"\n",
    "\n",
    "_check(test_results, names=[\"results\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "day-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "day = {\n",
    "    17: [\"Латте;220;2\", \"Круассан;140;1\"],\n",
    "    18: [],\n",
    "    19: [\"Раф;260;1\", \"Чай;-120;1\"],\n",
    "    20: [\"Какао;190;x2\"],\n",
    "    21: [\"Эспрессо;150;3\"],\n",
    "}\n",
    "results = []\n",
    "for number, texts in day.items():\n",
    "    try:\n",
    "        order = Order(number)\n",
    "        for text in texts:\n",
    "            order.add(parse_line(text))\n",
    "        results.append(f\"№{number}: {order.close()} ₽\")\n",
    "    except ShopError as error:\n",
    "        results.append(f\"№{number}: ошибка — {error}\")\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "day-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Итог"
   ],
   "id": "text-70"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Касса за день\n",
    "print(\"Касса за день\")\n",
    "for line in results:\n",
    "    print(\" \", line)\n",
    "closed = [line for line in results if \"ошибка\" not in line]\n",
    "print(f\"проведено заказов: {len(closed)} из {len(results)}\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "summary"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*После решения всех упражнений урока:*\n",
    "\n",
    "Из пяти заказов прошли два: №17 на 580 ₽ и №21 на 450 ₽. Остальные касса не провела, но объяснила почему:\n",
    "пустой заказ, отрицательная цена чая, буква в количестве какао. Ни одна ошибка не уронила кассу, а ошибки\n",
    "в самом коде — опечатки, неверные вызовы — `except ShopError` не спрятал бы."
   ],
   "id": "component-75"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иерархия исключений сделала отчёт простым: касса знает об одном классе `ShopError` и не перечисляет все\n",
    "виды ошибок. Новая проверка — скажем, «товара нет в меню» — это ещё один подкласс, и цикл дня не меняется.\n",
    "Остался итоговый проект: собрать всё, что было в курсе, в одну кассу."
   ],
   "id": "text-80"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}