From 5d51d763e2947e1c528fadba120bb88d00a688d7 Mon Sep 17 00:00:00 2001 From: Vova Date: Fri, 25 Sep 2026 19:03:08 +0300 Subject: [PATCH 1/8] Update constants.py --- src/part1/constants.py | 37 ++++++++----------------------------- 1 file changed, 8 insertions(+), 29 deletions(-) diff --git a/src/part1/constants.py b/src/part1/constants.py index 9abfbba2..4aa78ccf 100644 --- a/src/part1/constants.py +++ b/src/part1/constants.py @@ -1,38 +1,17 @@ -"""Bit layout and default epoch for the Twitter Snowflake ID generator. - -A Snowflake identifier is a 63-bit positive integer packed as follows, from -the most significant bit downwards: - - 1 bit unused sign bit, always zero - 41 bits milliseconds elapsed since a custom epoch - 10 bits node identifier - 12 bits per-millisecond sequence counter - -The shift and mask constants should be derived from the bit widths so that -changing a width keeps everything else consistent. -""" - from typing import Final - -# TODO: замените заглушки (0) на корректные значения, см. TASK.md. -# Все константы, зависящие от ёмкостей *_BITS, должны вычисляться из них. - # Twitter's original Snowflake epoch: 2010-11-04 01:42:54.657 UTC. -EPOCH_MS_DEFAULT: Final[int] = 0 +EPOCH_MS_DEFAULT: Final[int] = 1288834974657 # Node identifier used when the caller does not supply one. -NODE_ID_DEFAULT: Final[int] = 0 +NODE_ID_DEFAULT: Final[int] = 1 # Width of each field, in bits. -TIMESTAMP_BITS: Final[int] = 0 -NODE_ID_BITS: Final[int] = 0 -SEQUENCE_ID_BITS: Final[int] = 0 +TIMESTAMP_BITS: Final[int] = 41 +NODE_ID_BITS: Final[int] = 10 +SEQUENCE_ID_BITS: Final[int] = 12 # Largest value each field can hold. -TIMESTAMP_MS_MAX: Final[int] = 0 -NODE_ID_MAX: Final[int] = 0 -SEQUENCE_ID_MAX: Final[int] = 0 - -# Здесь можно добавить собственные вспомогательные константы -# (например, сдвиги полей при сборке идентификатора). +TIMESTAMP_MS_MAX: Final[int] = (1 << TIMESTAMP_BITS) - 1 +NODE_ID_MAX: Final[int] = (1 << NODE_ID_BITS) - 1 +SEQUENCE_ID_MAX: Final[int] = (1 << SEQUENCE_ID_BITS) - 1 From f0dd66ababa6483c32231a0420db6cafae024b0b Mon Sep 17 00:00:00 2001 From: Vova Date: Fri, 25 Sep 2026 19:03:29 +0300 Subject: [PATCH 2/8] Update snowflake.py --- src/part1/snowflake.py | 121 ++++++++++++----------------------------- 1 file changed, 35 insertions(+), 86 deletions(-) diff --git a/src/part1/snowflake.py b/src/part1/snowflake.py index d3abf050..7be71625 100644 --- a/src/part1/snowflake.py +++ b/src/part1/snowflake.py @@ -1,18 +1,3 @@ -"""Twitter Snowflake identifier generator. - -Snowflake produces roughly time-ordered 64-bit integer identifiers without -coordination between nodes. Each identifier packs the milliseconds elapsed -since a custom epoch, a node identifier and a per-millisecond sequence counter -into a single 63-bit positive integer (see ``constants`` for the layout). - -The public entry point is :func:`generate_snowflake_id`. It is stateless: the -caller passes the sequence counter on every call and is responsible for -advancing it within a millisecond and resetting it when the clock ticks over. - -Each packed field can be read back on its own with :func:`decode_timestamp_ms`, -:func:`decode_node_id` and :func:`decode_sequence_id`. -""" - import time # noqa: F401 from .constants import ( # noqa: F401 @@ -21,65 +6,27 @@ NODE_ID_MAX, SEQUENCE_ID_MAX, TIMESTAMP_MS_MAX, + TIMESTAMP_BITS, + NODE_ID_BITS, + SEQUENCE_ID_BITS, + ) def read_current_millis(epoch_ms: int) -> int: - """Read the number of milliseconds elapsed since the custom epoch. - - Args: - epoch_ms: The custom epoch expressed as Unix milliseconds. - - Returns: - The count of whole milliseconds between ``epoch_ms`` and now. May be - negative if ``epoch_ms`` lies in the future. - """ - # TODO: реализуйте функцию - return 0 - + return time.time_ns()//10**6 - epoch_ms def decode_timestamp_ms(snowflake_id: int, epoch_ms: int = EPOCH_MS_DEFAULT) -> int: - """Read the timestamp field out of a Snowflake identifier. - - Args: - snowflake_id: An identifier produced against the same epoch. - epoch_ms: The epoch the identifier was generated against. Defaults to - the original Twitter epoch (2010-11-04 01:42:54.657 UTC). - - Returns: - The absolute Unix time in milliseconds at which the identifier was - generated. - """ - # TODO: реализуйте функцию - return 0 + stored_time = snowflake_id >> (NODE_ID_BITS + SEQUENCE_ID_BITS) + return stored_time + epoch_ms def decode_node_id(snowflake_id: int) -> int: - """Read the node identifier field out of a Snowflake identifier. - - Args: - snowflake_id: An identifier produced by :func:`generate_snowflake_id`. - - Returns: - The node identifier packed into ``snowflake_id``, in the range - ``[0, NODE_ID_MAX]``. - """ - # TODO: реализуйте функцию - return 0 + return (snowflake_id >> SEQUENCE_ID_BITS) & NODE_ID_MAX def decode_sequence_id(snowflake_id: int) -> int: - """Read the sequence counter field out of a Snowflake identifier. - - Args: - snowflake_id: An identifier produced by :func:`generate_snowflake_id`. - - Returns: - The per-millisecond sequence counter packed into ``snowflake_id``, in - the range ``[0, SEQUENCE_ID_MAX]``. - """ - # TODO: реализуйте функцию - return 0 + return snowflake_id & SEQUENCE_ID_MAX def generate_snowflake_id( @@ -87,28 +34,30 @@ def generate_snowflake_id( node_id: int = NODE_ID_DEFAULT, epoch_ms: int = EPOCH_MS_DEFAULT, ) -> int | None: - """Build and return a Snowflake identifier for the current millisecond. - - The function is stateless: the caller passes the per-millisecond sequence - counter explicitly. It is the caller's responsibility to increment - ``sequence_id`` for identifiers minted within the same millisecond and to - reset it once the clock advances. - - Args: - sequence_id: The per-millisecond sequence counter, in the range - ``[0, SEQUENCE_ID_MAX]``. - node_id: The identifier of this node, in the range ``[0, NODE_ID_MAX]``. - Optional; defaults to ``NODE_ID_DEFAULT``. - epoch_ms: The start of the epoch as Unix milliseconds. Optional; - defaults to the original Twitter epoch (2010-11-04 01:42:54.657 - UTC). - Returns: - The Snowflake identifier as a positive 63-bit integer, or ``None`` if - ``node_id`` is outside ``[0, NODE_ID_MAX]``, ``sequence_id`` is outside - ``[0, SEQUENCE_ID_MAX]``, or the elapsed time no longer fits in the - timestamp field (roughly 69 years after ``epoch_ms``). In each of those - cases an explanatory message is printed to stdout first. - """ - # TODO: реализуйте функцию - return 0 + if not (0 <= node_id <= NODE_ID_MAX): + print( + f"node_id must be in [0, {NODE_ID_MAX}], got {node_id}" + ) + return None + + if not (0 <= sequence_id <= SEQUENCE_ID_MAX): + print( + f"sequence_id must be in [0, {SEQUENCE_ID_MAX}], got {sequence_id}" + ) + return None + + timestamp_ms = read_current_millis(epoch_ms) + if not (0 <= timestamp_ms <= TIMESTAMP_MS_MAX): + print( + f"timestamp_ms value is overflows {TIMESTAMP_BITS} bits:" + f"{timestamp_ms} > {TIMESTAMP_MS_MAX}" + ) + return None + + snowflake_id = ( + (timestamp_ms << (NODE_ID_BITS + SEQUENCE_ID_BITS)) + | (node_id << SEQUENCE_ID_BITS) + | sequence_id + ) + return snowflake_id From a1d1acc4f934d6b14e906eb63c4c3192652ec6e8 Mon Sep 17 00:00:00 2001 From: Vladimir Date: Fri, 25 Sep 2026 20:23:28 +0300 Subject: [PATCH 3/8] bugs fixed --- src/part1/constants.py | 1 + src/part1/snowflake.py | 22 +++++++++------------- 2 files changed, 10 insertions(+), 13 deletions(-) diff --git a/src/part1/constants.py b/src/part1/constants.py index 4aa78ccf..9205c47d 100644 --- a/src/part1/constants.py +++ b/src/part1/constants.py @@ -1,5 +1,6 @@ from typing import Final + # Twitter's original Snowflake epoch: 2010-11-04 01:42:54.657 UTC. EPOCH_MS_DEFAULT: Final[int] = 1288834974657 diff --git a/src/part1/snowflake.py b/src/part1/snowflake.py index 7be71625..73cded6c 100644 --- a/src/part1/snowflake.py +++ b/src/part1/snowflake.py @@ -1,20 +1,20 @@ -import time # noqa: F401 +import time -from .constants import ( # noqa: F401 +from .constants import ( EPOCH_MS_DEFAULT, + NODE_ID_BITS, NODE_ID_DEFAULT, NODE_ID_MAX, + SEQUENCE_ID_BITS, SEQUENCE_ID_MAX, - TIMESTAMP_MS_MAX, TIMESTAMP_BITS, - NODE_ID_BITS, - SEQUENCE_ID_BITS, - + TIMESTAMP_MS_MAX, ) def read_current_millis(epoch_ms: int) -> int: - return time.time_ns()//10**6 - epoch_ms + return time.time_ns() // 10**6 - epoch_ms + def decode_timestamp_ms(snowflake_id: int, epoch_ms: int = EPOCH_MS_DEFAULT) -> int: stored_time = snowflake_id >> (NODE_ID_BITS + SEQUENCE_ID_BITS) @@ -36,15 +36,11 @@ def generate_snowflake_id( ) -> int | None: if not (0 <= node_id <= NODE_ID_MAX): - print( - f"node_id must be in [0, {NODE_ID_MAX}], got {node_id}" - ) + print(f"node_id must be in [0, {NODE_ID_MAX}], got {node_id}") return None if not (0 <= sequence_id <= SEQUENCE_ID_MAX): - print( - f"sequence_id must be in [0, {SEQUENCE_ID_MAX}], got {sequence_id}" - ) + print(f"sequence_id must be in [0, {SEQUENCE_ID_MAX}], got {sequence_id}") return None timestamp_ms = read_current_millis(epoch_ms) From de59f1f0df3fa19c3349e08e21d5de16bc82b210 Mon Sep 17 00:00:00 2001 From: Vladimir Date: Fri, 2 Oct 2026 23:52:28 +0300 Subject: [PATCH 4/8] updated files 2 --- src/part2/cart.py | 145 +++++++++++-------- src/part2/crud.py | 126 +++++----------- src/part2/storage.py | 30 +--- src/part2/utils.py | 27 +--- "srcpart2crud.py\357\200\27245\357\200\2721" | 0 5 files changed, 132 insertions(+), 196 deletions(-) create mode 100644 "srcpart2crud.py\357\200\27245\357\200\2721" diff --git a/src/part2/cart.py b/src/part2/cart.py index 063f9aea..5d337854 100644 --- a/src/part2/cart.py +++ b/src/part2/cart.py @@ -1,18 +1,7 @@ -"""Shopping-cart operations layered on top of the product store. - -The cart is a plain list of tuples, one :data:`CartLine` -- -``(product_id, quantity)`` -- per distinct product. Moving units between the -store and the cart keeps the two sides in balance: :func:`add_to_cart` takes -units out of stock, :func:`remove_from_cart` puts them back. - -Like the CRUD layer, the failure path never raises -- the operation prints -an explanatory message to stdout and returns ``None``. -""" - from typing import Final -from .crud import read_product, update_product # noqa: F401 -from .storage import ( # noqa: F401 +from .crud import read_product, update_product +from .storage import ( NAME_INDEX, PRICE_INDEX, QUANTITY_INDEX, @@ -24,7 +13,7 @@ # TODO: задайте позиции полей внутри кортежа CartLine LINE_PRODUCT_ID_INDEX: Final = 0 -LINE_QUANTITY_INDEX: Final = 0 +LINE_QUANTITY_INDEX: Final = 1 def add_to_cart( @@ -33,28 +22,41 @@ def add_to_cart( product_id: int, quantity: int, ) -> CartLine | None: - """Move ``quantity`` units of ``product_id`` from the store into ``cart``. - - The product is looked up in ``storage``. If it is missing, a message is - printed (by :func:`~src.part2.crud.read_product`) and nothing - changes. If the store holds fewer units than requested, an explanatory - message is printed and nothing changes. Otherwise the store record is - decremented by ``quantity`` and the cart line for ``product_id`` gains - ``quantity`` units -- a new line is created when the cart had none. - - Args: - storage: The product store to draw stock from; modified in place on - success. - cart: The cart to add the units to; modified in place on success. - product_id: The identifier of the product to add. - quantity: Number of units to move into the cart. - - Returns: - The cart line for ``product_id`` after the addition, or ``None`` - when the product is unknown or the store cannot cover the request. - """ - # TODO: реализуйте функцию - return (0, 0) + """Move ``quantity`` units of ``product_id`` from the store into ``cart``.""" + # 1. Ищем товар. read_product сам напечатает сообщение, если не нашёл. + product = read_product(storage, product_id) + if product is None: + return None + + product_name = product[NAME_INDEX] + product_price = product[PRICE_INDEX] + product_quantity = product[QUANTITY_INDEX] + + # 2. Проверяем остаток + if product_quantity < quantity: + print( + f"not enough stock for product {product_id}: " + f"{product_quantity} available, {quantity} requested" + ) + return None + + # 3. Списываем со склада + update_product( + storage, + product_id, + (product_name, product_price, product_quantity - quantity), + ) + + # 4. Обновляем строку корзины или создаём новую + for i, line in enumerate(cart): + if line[LINE_PRODUCT_ID_INDEX] == product_id: + new_line = (product_id, line[LINE_QUANTITY_INDEX] + quantity) + cart[i] = new_line + return new_line + + new_line = (product_id, quantity) + cart.append(new_line) + return new_line def remove_from_cart( @@ -63,27 +65,50 @@ def remove_from_cart( product_id: int, quantity: int, ) -> CartLine | None: - """Move ``quantity`` units of ``product_id`` from ``cart`` back to the store. - - The cart line for ``product_id`` is looked up. If there is none, a - message is printed and nothing changes. If the line holds fewer units - than requested, an explanatory message is printed and nothing changes. - Otherwise the cart line loses ``quantity`` units -- the line is dropped - when it reaches zero -- and the store record gains ``quantity`` units - back. - - Args: - storage: The product store to return stock to; modified in place on - success. - cart: The cart to take the units from; modified in place on - success. - product_id: The identifier of the product to remove. - quantity: Number of units to move back into the store. - - Returns: - The cart line for ``product_id`` after the removal (a quantity of - zero means the line was dropped), or ``None`` when the cart has no - line for the product or holds too few units. - """ - # TODO: реализуйте функцию - return (0, 0) + """Move ``quantity`` units of ``product_id`` from ``cart`` back to the store.""" + # 1. Ищем строку корзины + line_index = None + for i, line in enumerate(cart): + if line[LINE_PRODUCT_ID_INDEX] == product_id: + line_index = i + break + + if line_index is None: + print(f"product {product_id} is not in the cart") + return None + + # 2. Проверяем, хватает ли единиц в строке + line_quantity = cart[line_index][LINE_QUANTITY_INDEX] + if line_quantity < quantity: + print( + f"not enough units of product {product_id} in cart: " + f"{line_quantity} available, {quantity} requested" + ) + return None + + # 3. Находим товар на складе, чтобы вернуть ему единицы + product = read_product(storage, product_id) + if product is None: + print(f"product {product_id} is missing from the store") + return None + + product_name = product[NAME_INDEX] + product_price = product[PRICE_INDEX] + product_quantity = product[QUANTITY_INDEX] + + # 4. Возвращаем единицы на склад + update_product( + storage, + product_id, + (product_name, product_price, product_quantity + quantity), + ) + + # 5. Уменьшаем строку; если стало 0 — удаляем + remaining = line_quantity - quantity + if remaining == 0: + del cart[line_index] + return (product_id, 0) + + new_line = (product_id, remaining) + cart[line_index] = new_line + return new_line \ No newline at end of file diff --git a/src/part2/crud.py b/src/part2/crud.py index d026cbcb..4ac0c78d 100644 --- a/src/part2/crud.py +++ b/src/part2/crud.py @@ -1,79 +1,46 @@ -"""Create/read/update/delete operations over the in-memory product store. - -Every operation takes the store -- a list of -:data:`~src.part2.storage.Product` tuples -- as its first argument and -works on it in place. The failure path never raises: the operation prints -an explanatory message to stdout and returns ``None``. - -The identifier of a new product is derived from the store itself -(:func:`generate_product_id`): one past the greatest identifier in use, or -:data:`~src.part2.storage.PRODUCT_ID_MIN` when the store is empty. -Product names are kept unique -- :func:`create_product` refuses a name that -is already taken. -""" - from decimal import Decimal -from .storage import ( # noqa: F401 +from .storage import ( NAME_INDEX, PRODUCT_ID_INDEX, PRODUCT_ID_MIN, Product, ) -from .utils import normalize_price # noqa: F401 +from .utils import normalize_price def generate_product_id(storage: list[Product]) -> int: - """Choose the identifier for the next product added to ``storage``. - - Args: - storage: The product store to inspect. - - Returns: - One past the greatest identifier currently held in ``storage``, or - :data:`~src.part2.storage.PRODUCT_ID_MIN` when ``storage`` is - empty. - """ - # TODO: реализуйте функцию - return 0 + if not storage: + return PRODUCT_ID_MIN + return max(product[PRODUCT_ID_INDEX] for product in storage) + 1 def create_product( storage: list[Product], fields: tuple[str, Decimal, int] ) -> int | None: - """Append a new product to ``storage`` and return its new identifier. - Args: - storage: The product store to append to; modified in place on - success. - fields: A ``(name, price, quantity)`` tuple describing the product. - ``price`` is a :class:`~decimal.Decimal` amount and is rounded - to the stored money precision before it is saved. + name, price, quantity = fields - Returns: - The identifier generated for the new product, or ``None`` when a - product with the same name already exists. In the ``None`` case - ``storage`` is left unchanged and a message naming the clashing - name is printed. - """ - # TODO: реализуйте функцию - return 0 + if any(product[NAME_INDEX] == name for product in storage): + print(f"product name {name} is already taken.") + return None + new_product_id = generate_product_id(storage) -def read_product(storage: list[Product], product_id: int) -> Product | None: - """Return the product stored under ``product_id``. + normalized_price = normalize_price(price) - Args: - storage: The product store to search. - product_id: The identifier to look up. + new_product = (new_product_id, name, normalized_price, quantity) + storage.append(new_product) + return new_product_id - Returns: - The matching ``(product_id, name, price, quantity)`` record, or - ``None`` when no product carries that identifier (a message is - printed in that case). - """ - # TODO: реализуйте функцию - return (0, "", Decimal(0), 0) + +def read_product(storage: list[Product], product_id: int) -> Product | None: + + for product in storage: + if product[PRODUCT_ID_INDEX] == product_id: + return product + print(f"no product with id {product_id}") + return None def update_product( @@ -81,40 +48,25 @@ def update_product( product_id: int, fields: tuple[str, Decimal, int], ) -> Product | None: - """Overwrite the fields of the product stored under ``product_id``. + name, price, quantity = fields + normalized_price = normalize_price(price) - The identifier itself is preserved; only ``name``, ``price`` and - ``quantity`` are replaced. + for i, product in enumerate(storage): + if product[PRODUCT_ID_INDEX] == product_id: + updated = (product_id, name, normalized_price, quantity) + storage[i] = updated + return updated - Args: - storage: The product store to modify; the matching record is - replaced in place on success. - product_id: The identifier of the product to change. - fields: A ``(name, price, quantity)`` tuple with the new values. - ``price`` is a :class:`~decimal.Decimal` amount and is rounded - to the stored money precision before it is saved. - - Returns: - The updated ``(product_id, name, price, quantity)`` record, or - ``None`` when no product carries that identifier (``storage`` is - left unchanged and a message is printed). - """ - # TODO: реализуйте функцию - return (0, "", Decimal(0), 0) + print(f"no product with id {product_id}") + return None def delete_product(storage: list[Product], product_id: int) -> int | None: - """Remove the product stored under ``product_id`` from ``storage``. - - Args: - storage: The product store to remove from; modified in place on - success. - product_id: The identifier of the product to remove. - - Returns: - ``product_id`` when a product was removed, or ``None`` when no - product carried that identifier (``storage`` is left unchanged and - a message is printed). - """ - # TODO: реализуйте функцию - return 0 + + for product in storage: + if product[PRODUCT_ID_INDEX] == product_id: + storage.remove(product) + return product_id + + print(f"no product with id {product_id}") + return None \ No newline at end of file diff --git a/src/part2/storage.py b/src/part2/storage.py index b63d5fc7..81651a75 100644 --- a/src/part2/storage.py +++ b/src/part2/storage.py @@ -1,34 +1,12 @@ -"""In-memory product store for the shop CRUD exercise. - -The store is deliberately primitive: a plain list of tuples, with no -persistence, no indexing and no schema enforcement. Each element is a -:data:`Product` record -- a ``(product_id, name, price, quantity)`` tuple -where: - -* ``product_id`` -- unique positive integer key, assigned by the create - operation in :mod:`src.part2.crud`; -* ``name`` -- human-readable product name, unique across the store; -* ``price`` -- price of a single unit, held as a :class:`~decimal.Decimal` - amount rounded to a fixed number of decimal places (see - :func:`src.part2.utils.normalize_price`) so that money is never - subject to binary floating-point error; -* ``quantity`` -- number of units currently in stock. - -Field positions are exposed as ``*_INDEX`` constants so callers never -hard-code tuple offsets. -""" - from decimal import Decimal from typing import Final type Product = tuple[int, str, Decimal, int] -# TODO: задайте позиции полей внутри кортежа Product PRODUCT_ID_INDEX: Final = 0 -NAME_INDEX: Final = 0 -PRICE_INDEX: Final = 0 -QUANTITY_INDEX: Final = 0 +NAME_INDEX: Final = 1 +PRICE_INDEX: Final = 2 +QUANTITY_INDEX: Final = 3 -# TODO: задайте идентификатор первого товара в пустом хранилище -PRODUCT_ID_MIN: Final[int] = 0 +PRODUCT_ID_MIN: Final[int] = 1 diff --git a/src/part2/utils.py b/src/part2/utils.py index ec0348d3..b03ba2bd 100644 --- a/src/part2/utils.py +++ b/src/part2/utils.py @@ -1,29 +1,10 @@ -"""Standalone helpers shared by the hw4 storage and CRUD modules. - -For now this is limited to money handling: :func:`normalize_price` rounds a -raw :class:`~decimal.Decimal` amount to the fixed number of fractional -digits (:data:`PRICE_PRECISION`) that every stored price uses, keeping -currency values free of binary floating-point error. -""" - -from decimal import ROUND_HALF_UP, Decimal # noqa: F401 +from decimal import ROUND_HALF_UP, Decimal from typing import Final -# TODO: задайте число знаков после запятой и шаг квантования -PRICE_PRECISION: Final[int] = 0 -PRICE_STEP: Final = Decimal(0) +PRICE_PRECISION: Final[int] = 2 +PRICE_STEP: Final = Decimal(1).scaleb(-PRICE_PRECISION) def normalize_price(price: Decimal) -> Decimal: - """Round a price to the precision every stored record uses. - - Args: - price: The raw price amount. - - Returns: - ``price`` quantised to :data:`PRICE_PRECISION` fractional digits, - with halves rounded up. - """ - # TODO: реализуйте функцию - return Decimal(0) + return Decimal(price.quantize(PRICE_STEP, rounding=ROUND_HALF_UP)) diff --git "a/srcpart2crud.py\357\200\27245\357\200\2721" "b/srcpart2crud.py\357\200\27245\357\200\2721" new file mode 100644 index 00000000..e69de29b From 4db3a57f2dff6c80cce0ae80c4c79f02803c205c Mon Sep 17 00:00:00 2001 From: Vladimir Date: Fri, 2 Oct 2026 23:59:58 +0300 Subject: [PATCH 5/8] files updated --- src/part2/cart.py | 2 +- src/part2/crud.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/part2/cart.py b/src/part2/cart.py index 5d337854..cf0e4e96 100644 --- a/src/part2/cart.py +++ b/src/part2/cart.py @@ -111,4 +111,4 @@ def remove_from_cart( new_line = (product_id, remaining) cart[line_index] = new_line - return new_line \ No newline at end of file + return new_line diff --git a/src/part2/crud.py b/src/part2/crud.py index 4ac0c78d..919f0a39 100644 --- a/src/part2/crud.py +++ b/src/part2/crud.py @@ -67,6 +67,6 @@ def delete_product(storage: list[Product], product_id: int) -> int | None: if product[PRODUCT_ID_INDEX] == product_id: storage.remove(product) return product_id - + print(f"no product with id {product_id}") - return None \ No newline at end of file + return None From 19f76449621d2fae70716d9335caf8e5b611ef3d Mon Sep 17 00:00:00 2001 From: Vladimir Date: Mon, 12 Oct 2026 23:05:07 +0300 Subject: [PATCH 6/8] finished part 3 --- pyproject.toml | 1 + src/part3/crud.py | 10 +- src/part3/run_admin.py | 11 +- src/part3/tests1/__init__.py | 0 src/part3/tests1/test_general.py | 377 +++++++++++++++++++++++++++++++ src/part3/utils.py | 20 +- uv.lock | 65 +++++- 7 files changed, 467 insertions(+), 17 deletions(-) create mode 100644 src/part3/tests1/__init__.py create mode 100644 src/part3/tests1/test_general.py diff --git a/pyproject.toml b/pyproject.toml index 06fbe913..342512a4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -9,6 +9,7 @@ dependencies = [] [dependency-groups] dev = [ "mypy==2.3.1", + "pytest>=9.1.1", "ruff==0.16.8", ] diff --git a/src/part3/crud.py b/src/part3/crud.py index 2ea567fb..765c594d 100644 --- a/src/part3/crud.py +++ b/src/part3/crud.py @@ -27,7 +27,7 @@ def create_product( return None if any(product[NAME_INDEX] == name for product in storage): - print(f"product name {name} is already taken.") + print(f"product name '{name}' is already taken") return None new_product_id = generate_product_id(storage) @@ -59,6 +59,14 @@ def update_product( print("product name must not be blank") return None + for product in storage: + if ( + product[NAME_INDEX] == normalized_name + and product[PRODUCT_ID_INDEX] != product_id + ): + print(f"product name '{normalized_name}' is already taken") + return None + for i, product in enumerate(storage): if product[PRODUCT_ID_INDEX] == product_id: updated = (product_id, normalized_name, normalized_price, quantity) diff --git a/src/part3/run_admin.py b/src/part3/run_admin.py index dc5d034c..5b97dc40 100644 --- a/src/part3/run_admin.py +++ b/src/part3/run_admin.py @@ -78,18 +78,21 @@ def run_command(storage: list[Product], line: str) -> bool: case ["exit"]: return False case ["show"]: - get_storage_str_representation() + print_result(get_storage_str_representation(storage)) return True case ["read", product_id]: - print_result(read_product(storage, product_id)) + print_result(read_product(storage, int(product_id))) return True case ["delete", product_id]: - print_result(delete_product(storage, product_id)) + print_result(delete_product(storage, int(product_id))) + return True case ["update", product_id, *args] if len(args) >= 3: name = " ".join(args[:-2]) price = Decimal(args[-2]) quantity = int(args[-1]) - print_result(update_product(storage, product_id, (name, price, quantity))) + print_result( + update_product(storage, int(product_id), (name, price, quantity)) + ) return True case ["create", *args] if len(args) >= 3: name = " ".join(args[:-2]) diff --git a/src/part3/tests1/__init__.py b/src/part3/tests1/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/part3/tests1/test_general.py b/src/part3/tests1/test_general.py new file mode 100644 index 00000000..e3ddf358 --- /dev/null +++ b/src/part3/tests1/test_general.py @@ -0,0 +1,377 @@ +from decimal import Decimal, InvalidOperation + +import pytest + +from ..crud import create_product, update_product +from ..run_admin import HELP_TEXT, PROMPT, main, print_result, run_command, show_help +from ..storage import Product +from ..utils import ( + TABLE_HEADERS, + get_storage_str_representation, + normalize_product_name, +) + + +def test_normalize_product_name() -> None: + assert normalize_product_name(" Cordless Drill ") == "cordless drill" + assert normalize_product_name("abc def\tghi\tjkl") == "abc def ghi jkl" + assert normalize_product_name(" \t\n ") == "" + assert normalize_product_name("claw hammer") == "claw hammer" + assert normalize_product_name("") == "" + assert normalize_product_name("Cordless\tDrill\n ") == "cordless drill" + + +def test_constants() -> None: + assert PROMPT == "admin> " + assert TABLE_HEADERS == ("ID", "name", "price", "quantity") + + +def test_get_storage_str_representation() -> None: + # пустое хранилище: только заголовки и разделитель + assert ( + get_storage_str_representation([]) + == """| ID | name | price | quantity | +|----|------|-------|----------|""" + ) + + test1_str = """| ID | name | price | quantity | +|----|------|-------|----------| +| 1 | saw | 9.90 | 5 | +| 2 | axe | 12.00 | 8 |""" + assert ( + get_storage_str_representation( + [(1, "saw", Decimal("9.90"), 5), (2, "axe", Decimal("12.00"), 8)] + ) + == test1_str + ) + + test2_str = """| ID | name | price | quantity | +|----|------------|---------|----------| +| 10 | compressor | 1299.99 | 3 | +| 2 | nail | 2.50 | 500 |""" + assert ( + get_storage_str_representation( + [ + (10, "compressor", Decimal("1299.99"), 3), + (2, "nail", Decimal("2.50"), 500), + ] + ) + == test2_str + ) + + # инварианты: все строки одной длины, | на краях каждой строки + lines = test2_str.split("\n") + assert len({len(line) for line in lines}) == 1 + assert all(line.startswith("|") and line.endswith("|") for line in lines) + + +def test_create_product(capsys: pytest.CaptureFixture[str]) -> None: + taken: list[Product] = [ + (1, "saw", Decimal("9.90"), 5), + (2, "axe", Decimal("12.00"), 8), + ] + + # пустое имя: пустая строка или только пробельные символы + for name in ("", " ", " \n \t "): + assert create_product(taken, (name, Decimal("1.00"), 1)) is None + assert capsys.readouterr().out == "product name must not be blank\n" + + # имя занято, сравнение идёт по нормализованной форме + assert create_product(taken, ("saw", Decimal("1.00"), 1)) is None + assert capsys.readouterr().out == "product name 'saw' is already taken\n" + assert create_product(taken, (" SAw ", Decimal("1.00"), 1)) is None + assert capsys.readouterr().out == "product name 'saw' is already taken\n" + assert taken == [ + (1, "saw", Decimal("9.90"), 5), + (2, "axe", Decimal("12.00"), 8), + ] + + # успех: имя и цена нормализуются, id на один больше наибольшего + assert create_product(taken, ("sword", Decimal("1.00"), 1)) == 3 + assert taken == [ + (1, "saw", Decimal("9.90"), 5), + (2, "axe", Decimal("12.00"), 8), + (3, "sword", Decimal("1.00"), 1), + ] + + # id считается как max + 1, а не len + 1 + gappy: list[Product] = [ + (1, "saw", Decimal("9.90"), 5), + (3, "axe", Decimal("12.00"), 8), + ] + assert create_product(gappy, ("sword", Decimal("1.00"), 1)) == 4 + + # примеры из TASK.md + storage1: list[Product] = [] + first_id = create_product(storage1, (" Cordless Drill ", Decimal("89.999"), 12)) + second_id = create_product(storage1, ("Claw Hammer", Decimal("9.9"), 40)) + assert first_id == 1 + assert second_id == 2 + assert storage1 == [ + (1, "cordless drill", Decimal("90.00"), 12), + (2, "claw hammer", Decimal("9.90"), 40), + ] + + storage2: list[Product] = [] + assert create_product(storage2, ("cordless drill", Decimal(50), 3)) == 1 + result = create_product(storage2, (" CORDLESS DRILL ", Decimal(75), 1)) + assert result is None + assert capsys.readouterr().out == "product name 'cordless drill' is already taken\n" + assert storage2 == [(1, "cordless drill", Decimal("50.00"), 3)] + + storage3: list[Product] = [] + result = create_product(storage3, (" ", Decimal(10), 5)) + assert result is None + assert capsys.readouterr().out == "product name must not be blank\n" + assert storage3 == [] + + +def test_update_product(capsys: pytest.CaptureFixture[str]) -> None: + storage1: list[Product] = [ + (1, "cordless drill", Decimal("90.00"), 12), + (2, "claw hammer", Decimal("9.90"), 40), + ] + + # успех: имя и цена нормализуются, идентификатор сохраняется + result = update_product(storage1, 2, (" Rubber Mallet ", Decimal("7.505"), 25)) + assert result == (2, "rubber mallet", Decimal("7.51"), 25) + assert storage1 == [ + (1, "cordless drill", Decimal("90.00"), 12), + (2, "rubber mallet", Decimal("7.51"), 25), + ] + + storage2: list[Product] = [ + (1, "cordless drill", Decimal("90.00"), 12), + (2, "claw hammer", Decimal("9.90"), 40), + ] + + # обновление под собственным именем (в другом написании) — не конфликт + result = update_product(storage2, 1, ("CORDLESS Drill", Decimal(85), 10)) + assert result == (1, "cordless drill", Decimal("85.00"), 10) + + storage3: list[Product] = [ + (1, "cordless drill", Decimal("90.00"), 12), + (2, "claw hammer", Decimal("9.90"), 40), + ] + + # имя занято другим товаром + result = update_product(storage3, 1, (" Claw Hammer ", Decimal(85), 10)) + assert result is None + assert capsys.readouterr().out == "product name 'claw hammer' is already taken\n" + assert storage3 == [ + (1, "cordless drill", Decimal("90.00"), 12), + (2, "claw hammer", Decimal("9.90"), 40), + ] + + storage4: list[Product] = [ + (1, "cordless drill", Decimal("90.00"), 12), + (2, "claw hammer", Decimal("9.90"), 40), + ] + + # товара с таким id нет + result = update_product(storage4, 99, ("saw", Decimal(20), 5)) + assert result is None + assert capsys.readouterr().out == "no product with id 99\n" + + # пустое имя отвергается до поиска по идентификатору + result = update_product(storage4, 99, (" ", Decimal(20), 5)) + assert result is None + assert capsys.readouterr().out == "product name must not be blank\n" + assert storage4 == [ + (1, "cordless drill", Decimal("90.00"), 12), + (2, "claw hammer", Decimal("9.90"), 40), + ] + + +def test_show_help(capsys: pytest.CaptureFixture[str]) -> None: + show_help() + assert capsys.readouterr().out == HELP_TEXT + "\n" + + +def test_print_result(capsys: pytest.CaptureFixture[str]) -> None: + print_result(None) + assert capsys.readouterr().out == "" + + print_result(42) + assert capsys.readouterr().out == "42\n" + + product: Product = (1, "saw", Decimal("9.90"), 5) + print_result(product) + assert capsys.readouterr().out == "(1, 'saw', Decimal('9.90'), 5)\n" + + +def sample_storage() -> list[Product]: + """A fresh store with two products, for the run_command tests.""" + return [ + (1, "cordless drill", Decimal("89.99"), 12), + (2, "claw hammer", Decimal("9.90"), 40), + ] + + +def test_run_command_help_exit(capsys: pytest.CaptureFixture[str]) -> None: + storage: list[Product] = [] + + assert run_command(storage, "help") is True + assert capsys.readouterr().out == HELP_TEXT + "\n" + + assert run_command(storage, "exit") is False + assert capsys.readouterr().out == "" + assert storage == [] + + +def test_run_command_create(capsys: pytest.CaptureFixture[str]) -> None: + storage: list[Product] = [] + + # имя нормализуется, цена округляется, печатается новый id + assert run_command(storage, "create Cordless Drill 89.99 12") is True + assert capsys.readouterr().out == "1\n" + + assert run_command(storage, "create claw hammer 9.9 40") is True + assert capsys.readouterr().out == "2\n" + assert storage == [ + (1, "cordless drill", Decimal("89.99"), 12), + (2, "claw hammer", Decimal("9.90"), 40), + ] + + +def test_run_command_show(capsys: pytest.CaptureFixture[str]) -> None: + storage: list[Product] = [] + + assert run_command(storage, "show") is True + assert capsys.readouterr().out == ( + "| ID | name | price | quantity |\n|----|------|-------|----------|\n" + ) + + run_command(storage, "create Cordless Drill 89.99 12") + run_command(storage, "create claw hammer 9.9 40") + capsys.readouterr() + + assert run_command(storage, "show") is True + assert capsys.readouterr().out == ( + "| ID | name | price | quantity |\n" + "|----|----------------|-------|----------|\n" + "| 1 | cordless drill | 89.99 | 12 |\n" + "| 2 | claw hammer | 9.90 | 40 |\n" + ) + + +def test_run_command_read(capsys: pytest.CaptureFixture[str]) -> None: + storage = sample_storage() + + assert run_command(storage, "read 1") is True + assert capsys.readouterr().out == "(1, 'cordless drill', Decimal('89.99'), 12)\n" + + assert run_command(storage, "read 5") is True + assert capsys.readouterr().out == "no product with id 5\n" + assert storage == [ + (1, "cordless drill", Decimal("89.99"), 12), + (2, "claw hammer", Decimal("9.90"), 40), + ] + + +def test_run_command_update(capsys: pytest.CaptureFixture[str]) -> None: + storage = sample_storage() + + assert run_command(storage, "update 2 mallet 7.50 30") is True + assert capsys.readouterr().out == "(2, 'mallet', Decimal('7.50'), 30)\n" + assert storage == [ + (1, "cordless drill", Decimal("89.99"), 12), + (2, "mallet", Decimal("7.50"), 30), + ] + + +def test_run_command_delete(capsys: pytest.CaptureFixture[str]) -> None: + storage = sample_storage() + + assert run_command(storage, "delete 2") is True + assert capsys.readouterr().out == "2\n" + + assert run_command(storage, "delete 2") is True + assert capsys.readouterr().out == "no product with id 2\n" + assert storage == [(1, "cordless drill", Decimal("89.99"), 12)] + + +def test_run_command_not_a_command(capsys: pytest.CaptureFixture[str]) -> None: + storage = sample_storage() + + # неизвестная команда, неверное число аргументов и create/update без + # слов имени: одно и то же сообщение, хранилище не меняется + for line in ( + "frobnicate 1 2", + "read 1 2 3", + "read", + "delete", + "help me", + "exit now", + "show extra", + "create 89.90 12", + "update 1 89.90 12", + ): + assert run_command(storage, line) is True + assert capsys.readouterr().out == f"'{line}' is not a command\n" + assert storage == [ + (1, "cordless drill", Decimal("89.99"), 12), + (2, "claw hammer", Decimal("9.90"), 40), + ] + + +# помогла написать нейронка +def test_run_command_invalid_arguments(capsys: pytest.CaptureFixture[str]) -> None: + storage = sample_storage() + + # id/цена/количество не разбираются: исключение (ловится в main), + # хранилище и stdout не меняются + for line, exc_type in ( + ("read abc", ValueError), + ("delete abc", ValueError), + ("update abc claw hammer 1.00 1", ValueError), + ("create foo 1.00 abc", ValueError), + ("create foo abc 5", InvalidOperation), + ("update 1 foo abc 2", InvalidOperation), + ): + with pytest.raises(exc_type): + run_command(storage, line) + assert capsys.readouterr().out == "" + assert storage == [ + (1, "cordless drill", Decimal("89.99"), 12), + (2, "claw hammer", Decimal("9.90"), 40), + ] + + +# помогла написать нейронка +def test_main_session( + monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str] +) -> None: + lines = iter( + [ + "create Cordless Drill 89.99 12", + "create claw hammer 9.9 40", + "show", + "read 5", + "exit", + ] + ) + monkeypatch.setattr("builtins.input", lambda prompt="": next(lines)) + main() + assert capsys.readouterr().out == ( + "1\n" + "2\n" + "| ID | name | price | quantity |\n" + "|----|----------------|-------|----------|\n" + "| 1 | cordless drill | 89.99 | 12 |\n" + "| 2 | claw hammer | 9.90 | 40 |\n" + "no product with id 5\n" + ) + + +# помогла написать нейронка +def test_main_catches_invalid_arguments( + monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str] +) -> None: + lines = iter(["create foo abc 5", "read x", "exit"]) + monkeypatch.setattr("builtins.input", lambda prompt="": next(lines)) + main() + assert capsys.readouterr().out == ( + "'create foo abc 5' names a command but its arguments are invalid\n" + "'read x' names a command but its arguments are invalid\n" + ) \ No newline at end of file diff --git a/src/part3/utils.py b/src/part3/utils.py index 89eeed93..f7717194 100644 --- a/src/part3/utils.py +++ b/src/part3/utils.py @@ -15,11 +15,11 @@ def normalize_price(price: Decimal) -> Decimal: def normalize_product_name(name: str) -> str: - return "".join(name.split().lower()) + return " ".join(name.lower().split()) -def rowing_product(product: Product) -> tuple: - return tuple( +def rowing_product(product: Product) -> tuple[str, ...]: + return ( str(product[PRODUCT_ID_INDEX]), product[NAME_INDEX], str(product[PRICE_INDEX]), @@ -27,24 +27,22 @@ def rowing_product(product: Product) -> tuple: ) -def drawing_row(cells: tuple[str, ...], widths: tuple[str, ...]) -> str: +def drawing_row(cells: tuple[str, ...], widths: tuple[int, ...]) -> str: new_row = tuple(cell.ljust(width) for cell, width in zip(cells, widths)) - new_row = " | " + " | ".join(new_row) + " |" - return new_row + return "| " + " | ".join(new_row) + " |" def get_storage_str_representation(storage: list[Product]) -> str: - rows = list(TABLE_HEADERS) + [rowing_product(i) for i in storage] + rows = [TABLE_HEADERS] + [rowing_product(product) for product in storage] widths_of_string = tuple( - (max(len(row[i])) for row in rows) for i in range(len(TABLE_HEADERS)) + max(len(row[i]) for row in rows) for i in range(len(TABLE_HEADERS)) ) header = drawing_row(TABLE_HEADERS, widths_of_string) sep_line = "|" + "|".join("-" * (width + 2) for width in widths_of_string) + "|" - lines = [drawing_row(row, widths_of_string) for row in rows[:1]] - rows = [header, sep_line].extend(lines) - table = "\n".join(rows) + lines = [drawing_row(row, widths_of_string) for row in rows[1:]] + table = "\n".join([header, sep_line] + lines) return table diff --git a/uv.lock b/uv.lock index 2a56c481..b51f5004 100644 --- a/uv.lock +++ b/uv.lock @@ -1,5 +1,5 @@ version = 1 -revision = 2 +revision = 3 requires-python = ">=3.12" resolution-markers = [ "python_full_version >= '3.15'", @@ -70,6 +70,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/91/a7/c8bbb2173f7a7131b3b2412035b2d814ab5ef2ce9799bd06f07c451640e4/ast_serialize-0.11.2-cp39-abi3-win_arm64.whl", hash = "sha256:dab599cbdcb7b45b18c41fad746645580b3a24357082b7f0e8921cd373804f27", size = 1136031, upload-time = "2026-09-13T18:48:54.04Z" }, ] +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" }, +] + [[package]] name = "librt" version = "0.15.0" @@ -234,6 +252,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, ] +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + [[package]] name = "pathspec" version = "1.1.1" @@ -251,6 +278,7 @@ source = { virtual = "." } [package.dev-dependencies] dev = [ { name = "mypy" }, + { name = "pytest" }, { name = "ruff" }, ] @@ -259,9 +287,44 @@ dev = [ [package.metadata.requires-dev] dev = [ { name = "mypy", specifier = "==2.3.1" }, + { name = "pytest", specifier = ">=9.1.1" }, { name = "ruff", specifier = "==0.16.8" }, ] +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pytest" +version = "9.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" }, +] + [[package]] name = "ruff" version = "0.16.8" From 8e1109dc6eac14d77070cf29e47f08f189a9f550 Mon Sep 17 00:00:00 2001 From: Vladimir Date: Mon, 12 Oct 2026 23:06:49 +0300 Subject: [PATCH 7/8] updated 3 part --- src/part3/tests1/__init__.py | 0 src/part3/tests1/test_general.py | 377 ------------------------------- 2 files changed, 377 deletions(-) delete mode 100644 src/part3/tests1/__init__.py delete mode 100644 src/part3/tests1/test_general.py diff --git a/src/part3/tests1/__init__.py b/src/part3/tests1/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/part3/tests1/test_general.py b/src/part3/tests1/test_general.py deleted file mode 100644 index e3ddf358..00000000 --- a/src/part3/tests1/test_general.py +++ /dev/null @@ -1,377 +0,0 @@ -from decimal import Decimal, InvalidOperation - -import pytest - -from ..crud import create_product, update_product -from ..run_admin import HELP_TEXT, PROMPT, main, print_result, run_command, show_help -from ..storage import Product -from ..utils import ( - TABLE_HEADERS, - get_storage_str_representation, - normalize_product_name, -) - - -def test_normalize_product_name() -> None: - assert normalize_product_name(" Cordless Drill ") == "cordless drill" - assert normalize_product_name("abc def\tghi\tjkl") == "abc def ghi jkl" - assert normalize_product_name(" \t\n ") == "" - assert normalize_product_name("claw hammer") == "claw hammer" - assert normalize_product_name("") == "" - assert normalize_product_name("Cordless\tDrill\n ") == "cordless drill" - - -def test_constants() -> None: - assert PROMPT == "admin> " - assert TABLE_HEADERS == ("ID", "name", "price", "quantity") - - -def test_get_storage_str_representation() -> None: - # пустое хранилище: только заголовки и разделитель - assert ( - get_storage_str_representation([]) - == """| ID | name | price | quantity | -|----|------|-------|----------|""" - ) - - test1_str = """| ID | name | price | quantity | -|----|------|-------|----------| -| 1 | saw | 9.90 | 5 | -| 2 | axe | 12.00 | 8 |""" - assert ( - get_storage_str_representation( - [(1, "saw", Decimal("9.90"), 5), (2, "axe", Decimal("12.00"), 8)] - ) - == test1_str - ) - - test2_str = """| ID | name | price | quantity | -|----|------------|---------|----------| -| 10 | compressor | 1299.99 | 3 | -| 2 | nail | 2.50 | 500 |""" - assert ( - get_storage_str_representation( - [ - (10, "compressor", Decimal("1299.99"), 3), - (2, "nail", Decimal("2.50"), 500), - ] - ) - == test2_str - ) - - # инварианты: все строки одной длины, | на краях каждой строки - lines = test2_str.split("\n") - assert len({len(line) for line in lines}) == 1 - assert all(line.startswith("|") and line.endswith("|") for line in lines) - - -def test_create_product(capsys: pytest.CaptureFixture[str]) -> None: - taken: list[Product] = [ - (1, "saw", Decimal("9.90"), 5), - (2, "axe", Decimal("12.00"), 8), - ] - - # пустое имя: пустая строка или только пробельные символы - for name in ("", " ", " \n \t "): - assert create_product(taken, (name, Decimal("1.00"), 1)) is None - assert capsys.readouterr().out == "product name must not be blank\n" - - # имя занято, сравнение идёт по нормализованной форме - assert create_product(taken, ("saw", Decimal("1.00"), 1)) is None - assert capsys.readouterr().out == "product name 'saw' is already taken\n" - assert create_product(taken, (" SAw ", Decimal("1.00"), 1)) is None - assert capsys.readouterr().out == "product name 'saw' is already taken\n" - assert taken == [ - (1, "saw", Decimal("9.90"), 5), - (2, "axe", Decimal("12.00"), 8), - ] - - # успех: имя и цена нормализуются, id на один больше наибольшего - assert create_product(taken, ("sword", Decimal("1.00"), 1)) == 3 - assert taken == [ - (1, "saw", Decimal("9.90"), 5), - (2, "axe", Decimal("12.00"), 8), - (3, "sword", Decimal("1.00"), 1), - ] - - # id считается как max + 1, а не len + 1 - gappy: list[Product] = [ - (1, "saw", Decimal("9.90"), 5), - (3, "axe", Decimal("12.00"), 8), - ] - assert create_product(gappy, ("sword", Decimal("1.00"), 1)) == 4 - - # примеры из TASK.md - storage1: list[Product] = [] - first_id = create_product(storage1, (" Cordless Drill ", Decimal("89.999"), 12)) - second_id = create_product(storage1, ("Claw Hammer", Decimal("9.9"), 40)) - assert first_id == 1 - assert second_id == 2 - assert storage1 == [ - (1, "cordless drill", Decimal("90.00"), 12), - (2, "claw hammer", Decimal("9.90"), 40), - ] - - storage2: list[Product] = [] - assert create_product(storage2, ("cordless drill", Decimal(50), 3)) == 1 - result = create_product(storage2, (" CORDLESS DRILL ", Decimal(75), 1)) - assert result is None - assert capsys.readouterr().out == "product name 'cordless drill' is already taken\n" - assert storage2 == [(1, "cordless drill", Decimal("50.00"), 3)] - - storage3: list[Product] = [] - result = create_product(storage3, (" ", Decimal(10), 5)) - assert result is None - assert capsys.readouterr().out == "product name must not be blank\n" - assert storage3 == [] - - -def test_update_product(capsys: pytest.CaptureFixture[str]) -> None: - storage1: list[Product] = [ - (1, "cordless drill", Decimal("90.00"), 12), - (2, "claw hammer", Decimal("9.90"), 40), - ] - - # успех: имя и цена нормализуются, идентификатор сохраняется - result = update_product(storage1, 2, (" Rubber Mallet ", Decimal("7.505"), 25)) - assert result == (2, "rubber mallet", Decimal("7.51"), 25) - assert storage1 == [ - (1, "cordless drill", Decimal("90.00"), 12), - (2, "rubber mallet", Decimal("7.51"), 25), - ] - - storage2: list[Product] = [ - (1, "cordless drill", Decimal("90.00"), 12), - (2, "claw hammer", Decimal("9.90"), 40), - ] - - # обновление под собственным именем (в другом написании) — не конфликт - result = update_product(storage2, 1, ("CORDLESS Drill", Decimal(85), 10)) - assert result == (1, "cordless drill", Decimal("85.00"), 10) - - storage3: list[Product] = [ - (1, "cordless drill", Decimal("90.00"), 12), - (2, "claw hammer", Decimal("9.90"), 40), - ] - - # имя занято другим товаром - result = update_product(storage3, 1, (" Claw Hammer ", Decimal(85), 10)) - assert result is None - assert capsys.readouterr().out == "product name 'claw hammer' is already taken\n" - assert storage3 == [ - (1, "cordless drill", Decimal("90.00"), 12), - (2, "claw hammer", Decimal("9.90"), 40), - ] - - storage4: list[Product] = [ - (1, "cordless drill", Decimal("90.00"), 12), - (2, "claw hammer", Decimal("9.90"), 40), - ] - - # товара с таким id нет - result = update_product(storage4, 99, ("saw", Decimal(20), 5)) - assert result is None - assert capsys.readouterr().out == "no product with id 99\n" - - # пустое имя отвергается до поиска по идентификатору - result = update_product(storage4, 99, (" ", Decimal(20), 5)) - assert result is None - assert capsys.readouterr().out == "product name must not be blank\n" - assert storage4 == [ - (1, "cordless drill", Decimal("90.00"), 12), - (2, "claw hammer", Decimal("9.90"), 40), - ] - - -def test_show_help(capsys: pytest.CaptureFixture[str]) -> None: - show_help() - assert capsys.readouterr().out == HELP_TEXT + "\n" - - -def test_print_result(capsys: pytest.CaptureFixture[str]) -> None: - print_result(None) - assert capsys.readouterr().out == "" - - print_result(42) - assert capsys.readouterr().out == "42\n" - - product: Product = (1, "saw", Decimal("9.90"), 5) - print_result(product) - assert capsys.readouterr().out == "(1, 'saw', Decimal('9.90'), 5)\n" - - -def sample_storage() -> list[Product]: - """A fresh store with two products, for the run_command tests.""" - return [ - (1, "cordless drill", Decimal("89.99"), 12), - (2, "claw hammer", Decimal("9.90"), 40), - ] - - -def test_run_command_help_exit(capsys: pytest.CaptureFixture[str]) -> None: - storage: list[Product] = [] - - assert run_command(storage, "help") is True - assert capsys.readouterr().out == HELP_TEXT + "\n" - - assert run_command(storage, "exit") is False - assert capsys.readouterr().out == "" - assert storage == [] - - -def test_run_command_create(capsys: pytest.CaptureFixture[str]) -> None: - storage: list[Product] = [] - - # имя нормализуется, цена округляется, печатается новый id - assert run_command(storage, "create Cordless Drill 89.99 12") is True - assert capsys.readouterr().out == "1\n" - - assert run_command(storage, "create claw hammer 9.9 40") is True - assert capsys.readouterr().out == "2\n" - assert storage == [ - (1, "cordless drill", Decimal("89.99"), 12), - (2, "claw hammer", Decimal("9.90"), 40), - ] - - -def test_run_command_show(capsys: pytest.CaptureFixture[str]) -> None: - storage: list[Product] = [] - - assert run_command(storage, "show") is True - assert capsys.readouterr().out == ( - "| ID | name | price | quantity |\n|----|------|-------|----------|\n" - ) - - run_command(storage, "create Cordless Drill 89.99 12") - run_command(storage, "create claw hammer 9.9 40") - capsys.readouterr() - - assert run_command(storage, "show") is True - assert capsys.readouterr().out == ( - "| ID | name | price | quantity |\n" - "|----|----------------|-------|----------|\n" - "| 1 | cordless drill | 89.99 | 12 |\n" - "| 2 | claw hammer | 9.90 | 40 |\n" - ) - - -def test_run_command_read(capsys: pytest.CaptureFixture[str]) -> None: - storage = sample_storage() - - assert run_command(storage, "read 1") is True - assert capsys.readouterr().out == "(1, 'cordless drill', Decimal('89.99'), 12)\n" - - assert run_command(storage, "read 5") is True - assert capsys.readouterr().out == "no product with id 5\n" - assert storage == [ - (1, "cordless drill", Decimal("89.99"), 12), - (2, "claw hammer", Decimal("9.90"), 40), - ] - - -def test_run_command_update(capsys: pytest.CaptureFixture[str]) -> None: - storage = sample_storage() - - assert run_command(storage, "update 2 mallet 7.50 30") is True - assert capsys.readouterr().out == "(2, 'mallet', Decimal('7.50'), 30)\n" - assert storage == [ - (1, "cordless drill", Decimal("89.99"), 12), - (2, "mallet", Decimal("7.50"), 30), - ] - - -def test_run_command_delete(capsys: pytest.CaptureFixture[str]) -> None: - storage = sample_storage() - - assert run_command(storage, "delete 2") is True - assert capsys.readouterr().out == "2\n" - - assert run_command(storage, "delete 2") is True - assert capsys.readouterr().out == "no product with id 2\n" - assert storage == [(1, "cordless drill", Decimal("89.99"), 12)] - - -def test_run_command_not_a_command(capsys: pytest.CaptureFixture[str]) -> None: - storage = sample_storage() - - # неизвестная команда, неверное число аргументов и create/update без - # слов имени: одно и то же сообщение, хранилище не меняется - for line in ( - "frobnicate 1 2", - "read 1 2 3", - "read", - "delete", - "help me", - "exit now", - "show extra", - "create 89.90 12", - "update 1 89.90 12", - ): - assert run_command(storage, line) is True - assert capsys.readouterr().out == f"'{line}' is not a command\n" - assert storage == [ - (1, "cordless drill", Decimal("89.99"), 12), - (2, "claw hammer", Decimal("9.90"), 40), - ] - - -# помогла написать нейронка -def test_run_command_invalid_arguments(capsys: pytest.CaptureFixture[str]) -> None: - storage = sample_storage() - - # id/цена/количество не разбираются: исключение (ловится в main), - # хранилище и stdout не меняются - for line, exc_type in ( - ("read abc", ValueError), - ("delete abc", ValueError), - ("update abc claw hammer 1.00 1", ValueError), - ("create foo 1.00 abc", ValueError), - ("create foo abc 5", InvalidOperation), - ("update 1 foo abc 2", InvalidOperation), - ): - with pytest.raises(exc_type): - run_command(storage, line) - assert capsys.readouterr().out == "" - assert storage == [ - (1, "cordless drill", Decimal("89.99"), 12), - (2, "claw hammer", Decimal("9.90"), 40), - ] - - -# помогла написать нейронка -def test_main_session( - monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str] -) -> None: - lines = iter( - [ - "create Cordless Drill 89.99 12", - "create claw hammer 9.9 40", - "show", - "read 5", - "exit", - ] - ) - monkeypatch.setattr("builtins.input", lambda prompt="": next(lines)) - main() - assert capsys.readouterr().out == ( - "1\n" - "2\n" - "| ID | name | price | quantity |\n" - "|----|----------------|-------|----------|\n" - "| 1 | cordless drill | 89.99 | 12 |\n" - "| 2 | claw hammer | 9.90 | 40 |\n" - "no product with id 5\n" - ) - - -# помогла написать нейронка -def test_main_catches_invalid_arguments( - monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str] -) -> None: - lines = iter(["create foo abc 5", "read x", "exit"]) - monkeypatch.setattr("builtins.input", lambda prompt="": next(lines)) - main() - assert capsys.readouterr().out == ( - "'create foo abc 5' names a command but its arguments are invalid\n" - "'read x' names a command but its arguments are invalid\n" - ) \ No newline at end of file From 2acac01a095c74aac84789cbc985dbcffdf3bd49 Mon Sep 17 00:00:00 2001 From: Vladimir Date: Sun, 1 Nov 2026 14:56:06 +0300 Subject: [PATCH 8/8] completed task 4 --- src/part3/run_admin.py | 31 ------- src/part4/cart.py | 129 ++++++++++++++------------- src/part4/crud.py | 195 ++++++++++++++++------------------------- src/part4/run_admin.py | 160 +++++++++++++++------------------ src/part4/storage.py | 43 +-------- src/part4/utils.py | 107 +++++++--------------- 6 files changed, 245 insertions(+), 420 deletions(-) diff --git a/src/part3/run_admin.py b/src/part3/run_admin.py index 5b97dc40..f35e09c6 100644 --- a/src/part3/run_admin.py +++ b/src/part3/run_admin.py @@ -1,34 +1,3 @@ -"""Interactive admin console for the part3 in-memory product store. - -Running this module starts a read-eval-print loop over a single product -store that lives in memory for the lifetime of the process. Every line -typed at the prompt is stripped of surrounding whitespace and matched -against the set of known commands: - -* ``help`` -- print the list of commands and what each one does; -* ``exit`` -- leave the loop and end the program; -* ``show`` -- print the whole store as a text table; -* ``create `` -- add a product; -* ``read `` -- print one product; -* ``update `` -- overwrite a product; -* ``delete `` -- remove a product. - -For ``create`` and ``update`` the price and quantity are always the last -two words of the line; everything between the verb (and, for ``update``, -the id) and those two words is joined with single spaces into the -product name, so a multi-word name such as ``Gibson SG Junior`` needs no -quoting. - -The four CRUD commands forward to :mod:`src.part3.crud`; whatever -that call returns is printed unless it is ``None``. A line whose first -word is not a known verb, or that carries the wrong number of arguments -for its verb, prints an "is not a command" notice. A line that names a -command correctly but whose id, price or quantity argument will not -parse prints a distinct "arguments are invalid" notice. Either way the -store is left untouched and the loop keeps running; only ``exit`` stops -it. -""" - from decimal import Decimal, InvalidOperation from typing import Final diff --git a/src/part4/cart.py b/src/part4/cart.py index aed9bb72..0cb02a86 100644 --- a/src/part4/cart.py +++ b/src/part4/cart.py @@ -1,18 +1,11 @@ -"""Shopping-cart operations layered on top of the product store. - -The cart is a plain dictionary mapping each product identifier to the -number of units of that product in the cart. Moving units between the -store and the cart keeps the two sides in balance: :func:`add_to_cart` takes -units out of stock, :func:`remove_from_cart` puts them back. - -Like the CRUD layer, the failure path never raises -- the operation prints -an explanatory message to stdout and returns ``None``. -""" - -from .storage import Product - - -# TODO: при необходимости добавьте свои вспомогательные функции +from .crud import ( + read_product, + update_product, +) +from .storage import ( + QUANTITY_KEY, + Product, +) def add_to_cart( @@ -22,32 +15,33 @@ def add_to_cart( product_id: str, quantity: int, ) -> int | None: - """Move ``quantity`` units of ``product_id`` from the store into ``cart``. + # 1. Ищем товар. read_product сам напечатает сообщение, если не нашёл + product = read_product(storage, product_id) + if product is None: + return None - The product is looked up in ``storage``. If it is missing, a message is - printed and nothing changes. If the store holds fewer units than - requested, an explanatory message is printed and nothing changes. - Otherwise the store record is decremented by ``quantity`` and the cart - gains ``quantity`` units of ``product_id`` -- the product is added when - the cart had none of it. + product_quantity = product[QUANTITY_KEY] - Args: - storage: The product store to draw stock from; modified in place on - success. - product_names: The normalised names in ``storage``; a - quantity-only change never renames a product, so it is left - unchanged here. - cart: The cart to add the units to; modified in place on success. - product_id: The identifier of the product to add. - quantity: Number of units to move into the cart. + # 2. Проверяем остаток + if product_quantity < quantity: + print( + f"not enough stock for product {product_id}: " + f"{product_quantity} available, {quantity} requested" + ) + return None - Returns: - The quantity of ``product_id`` in the cart after the addition, or - ``None`` when the product is unknown or the store cannot cover the - request. - """ - # TODO: реализуйте функцию - return 0 + # 3. Списываем со склада + update_product( + storage, + product_names, + product_id, + {QUANTITY_KEY: product_quantity - quantity}, + ) + + # 4. Добавляем quantity единиц в корзину + remaining = cart.get(product_id, 0) + quantity + cart[product_id] = remaining + return remaining def remove_from_cart( @@ -57,31 +51,40 @@ def remove_from_cart( product_id: str, quantity: int, ) -> int | None: - """Move ``quantity`` units of ``product_id`` from ``cart`` back to the store. + # 1. Есть ли товар в корзине + if product_id not in cart: + print(f"product {product_id} is not in the cart") + return None + + cart_quantity_now = cart[product_id] + + # 2. Достаточно ли quantity в корзине + if cart_quantity_now < quantity: + print( + f"cart holds only {cart_quantity_now} unit(s) of product " + f"{product_id}, cannot remove {quantity}" + ) + return None + + # 3. Есть ли товар в хранилище + product = read_product(storage, product_id) + if product is None: + return None + + product_quantity = product[QUANTITY_KEY] - If the cart holds no units of ``product_id``, a message is printed and - nothing changes. If it holds fewer units than requested, an explanatory - message is printed and nothing changes. If the product is missing from - ``storage``, a message is printed and nothing changes. Otherwise the cart loses - ``quantity`` units of the product -- the product is dropped from the - cart when its quantity reaches zero -- and the store record gains - ``quantity`` units back. + # Возвращаем на склад + update_product( + storage, + product_names, + product_id, + {QUANTITY_KEY: product_quantity + quantity}, + ) - Args: - storage: The product store to return stock to; modified in place on - success. - product_names: The normalised names in ``storage``; a - quantity-only change never renames a product, so it is left - unchanged here. - cart: The cart to take the units from; modified in place on - success. - product_id: The identifier of the product to remove. - quantity: Number of units to move back into the store. + remaining = cart_quantity_now - quantity + if remaining == 0: + del cart[product_id] + return 0 - Returns: - The quantity of ``product_id`` left in the cart after the removal - (zero means the product was dropped from the cart), or ``None`` when - the cart does not hold the product or holds too few units. - """ - # TODO: реализуйте функцию - return 0 + cart[product_id] = remaining + return remaining diff --git a/src/part4/crud.py b/src/part4/crud.py index 471eff00..21ed2ad5 100644 --- a/src/part4/crud.py +++ b/src/part4/crud.py @@ -1,48 +1,17 @@ -"""Create/read/update/delete operations over the in-memory product store. - -Every operation takes the store -- a dictionary mapping product id to its -:data:`~src.part4.storage.Product` record -- as its first argument and -works on it in place. ``create_product``, ``update_product`` and -``delete_product`` additionally take ``product_names``, the ``set[str]`` -of normalised names currently in ``storage`` (see -:mod:`src.part4.storage`), and keep it in sync with ``storage`` on -every successful call. The failure path never raises: the operation -prints an explanatory message to stdout and returns ``None``. - -The identifier of a new product is a freshly generated UUID string -(:func:`generate_product_id`), independent of insertion order or of any -identifier already in ``storage``. - -Every product name that reaches the store is passed through -:func:`~src.part4.utils.normalize_product_name` first. A name that -normalises to an empty string is rejected -- the operation prints a -message and changes nothing. Names are also kept unique -- -:func:`create_product` refuses a normalised name that is already taken, -and :func:`update_product` refuses one that is already taken by another -product -- via an O(1) membership test against ``product_names`` rather -than a scan over ``storage.values()``. -""" - -import uuid # noqa: F401 +import uuid from typing import Any -from .storage import ( # noqa: F401 +from .storage import ( NAME_KEY, PRICE_KEY, QUANTITY_KEY, Product, ) -from .utils import normalize_price, normalize_product_name # noqa: F401 +from .utils import normalize_price, normalize_product_name def generate_product_id() -> str: - """Generate an identifier for a new product. - - Returns: - A freshly generated UUID, stringified. - """ - # TODO: реализуйте функцию - return "" + return str(uuid.uuid4()) def create_product( @@ -50,46 +19,34 @@ def create_product( product_names: set[str], fields: dict[str, Any], ) -> str | None: - """Add a new product to ``storage`` and return its new identifier. - - Args: - storage: The product store to add to; modified in place on - success. - product_names: The normalised names already in ``storage``; the - new name is added to it in place on success. - fields: A dictionary with the ``name``, ``price`` and ``quantity`` - keys (see :data:`~src.part4.storage.NAME_KEY`, - :data:`~src.part4.storage.PRICE_KEY` and - :data:`~src.part4.storage.QUANTITY_KEY`) describing the - product. ``name`` is normalised (surrounding whitespace - stripped, lower-cased) before it is stored or compared. - ``price`` is a :class:`~decimal.Decimal` amount and is rounded - to the stored money precision before it is saved. - - Returns: - The identifier generated for the new product, or ``None`` when - ``name`` is blank once normalised or a product with the same - normalised name already exists. In the ``None`` case ``storage`` - and ``product_names`` are left unchanged and an explanatory - message is printed. - """ - # TODO: реализуйте функцию - return "" + normalized_name = normalize_product_name(fields[NAME_KEY]) + if not normalized_name: + print("product name must not be blank") + return None -def read_product(storage: dict[str, Product], product_id: str) -> Product | None: - """Return the product stored under ``product_id``. + if normalized_name in product_names: + print(f"product name '{normalized_name}' is already taken") + return None + + new_product_id = generate_product_id() + normalized_price = normalize_price(fields[PRICE_KEY]) + product_content = { + NAME_KEY: normalized_name, + PRICE_KEY: normalized_price, + QUANTITY_KEY: fields[QUANTITY_KEY], + } - Args: - storage: The product store to search. - product_id: The identifier to look up. + storage[new_product_id] = product_content + product_names.add(normalized_name) + return new_product_id - Returns: - The matching product record, or ``None`` when no product carries - that identifier (a message is printed in that case). - """ - # TODO: реализуйте функцию - return {} + +def read_product(storage: dict[str, Product], product_id: str) -> Product | None: + if product_id in storage: + return storage[product_id] + print(f"no product with id {product_id}") + return None def update_product( @@ -98,39 +55,44 @@ def update_product( product_id: str, fields: dict[str, Any], ) -> Product | None: - """Overwrite the fields of the product stored under ``product_id``. - - The identifier itself is preserved. ``fields`` may carry any subset of - ``name``, ``price`` and ``quantity``; a key that is missing keeps the - value the product already has, so a caller can update a single field - without repeating the other two. - - Args: - storage: The product store to modify; the matching record is - updated in place on success. - product_names: The normalised names already in ``storage``; on a - successful rename the old name is removed from it and the new - one added. - product_id: The identifier of the product to change. - fields: A dictionary with any of the ``name``, ``price`` and - ``quantity`` keys (see :data:`~src.part4.storage.NAME_KEY`, - :data:`~src.part4.storage.PRICE_KEY` and - :data:`~src.part4.storage.QUANTITY_KEY`) holding the new - values. ``price`` is a :class:`~decimal.Decimal` amount and is - rounded to the stored money precision before it is saved. - Mutated in place: a ``name`` or ``price`` value present in - ``fields`` is overwritten with its normalised form. - - Returns: - The updated product record, or ``None`` when ``name`` is present - and blank once normalised, no product carries that identifier, or - the normalised name is already taken by another product. In every - ``None`` case ``storage`` and ``product_names`` are left unchanged - and an explanatory message is printed. Renaming a product to its - own current name is allowed. - """ - # TODO: реализуйте функцию - return {} + # 1. Товар должен существовать + if product_id not in storage: + print(f"no product with id {product_id}") + return None + + product = storage[product_id] + old_name = product[NAME_KEY] + + # 2-4. Нормализация и проверки для имени + if NAME_KEY in fields: + normalized_name = normalize_product_name(fields[NAME_KEY]) + if not normalized_name: + print("product name must not be blank") + return None + if normalized_name != old_name and normalized_name in product_names: + print(f"product name '{normalized_name}' is already taken") + return None + fields[NAME_KEY] = normalized_name + + # 5. Нормализация цены + if PRICE_KEY in fields: + fields[PRICE_KEY] = normalize_price(fields[PRICE_KEY]) + + # 6. Записываем поля в товар + if NAME_KEY in fields: + product[NAME_KEY] = fields[NAME_KEY] + if PRICE_KEY in fields: + product[PRICE_KEY] = fields[PRICE_KEY] + if QUANTITY_KEY in fields: + product[QUANTITY_KEY] = fields[QUANTITY_KEY] + + # 7. Обновляем индекс при переименовании + current_name = product[NAME_KEY] + if current_name != old_name: + product_names.discard(old_name) + product_names.add(current_name) + + return product def delete_product( @@ -138,20 +100,11 @@ def delete_product( product_names: set[str], product_id: str, ) -> str | None: - """Remove the product stored under ``product_id`` from ``storage``. - - Args: - storage: The product store to remove from; modified in place on - success. - product_names: The normalised names already in ``storage``; the - departing product's name is removed from it in place on - success. - product_id: The identifier of the product to remove. - - Returns: - ``product_id`` when a product was removed, or ``None`` when no - product carried that identifier (``storage`` and ``product_names`` - are left unchanged and a message is printed). - """ - # TODO: реализуйте функцию - return "" + if product_id in storage: + name = storage[product_id][NAME_KEY] + del storage[product_id] + product_names.discard(name) + return product_id + + print(f"no product with id {product_id}") + return None diff --git a/src/part4/run_admin.py b/src/part4/run_admin.py index 2247b29b..8cbca9a3 100644 --- a/src/part4/run_admin.py +++ b/src/part4/run_admin.py @@ -1,110 +1,95 @@ -"""Interactive admin console for the part4 in-memory product store. - -Running this module starts a read-eval-print loop over a single product -store that lives in memory for the lifetime of the process. Every line -typed at the prompt is stripped of surrounding whitespace and matched, -with a ``match`` statement, against the set of known commands: - -* ``help`` -- print the list of commands and what each one does; -* ``exit`` -- leave the loop and end the program; -* ``show`` -- print the whole store as a text table; -* ``create `` -- add a product; -* ``read `` -- print one product; -* ``update `` -- overwrite a product; -* ``delete `` -- remove a product. - -For ``create`` and ``update`` the price and quantity are always the last -two words of the line; everything between the verb (and, for ``update``, -the id) and those two words is joined with single spaces into the -product name, so a multi-word name such as ``Gibson SG Junior`` needs no -quoting. - -The four CRUD commands forward to :mod:`src.part4.crud`; whatever -that call returns is printed unless it is ``None``. A line whose first -word is not a known verb, or that carries the wrong number of arguments -for its verb, prints an "is not a command" notice. A line that names a -command correctly but whose price or quantity argument will not parse -prints a distinct "arguments are invalid" notice. Either way the store -is left untouched and the loop keeps running; only ``exit`` stops it. -""" - -from decimal import Decimal, InvalidOperation # noqa: F401 +from decimal import Decimal, InvalidOperation from typing import Final -from .crud import ( # noqa: F401 +from .crud import ( create_product, delete_product, read_product, update_product, ) -from .storage import NAME_KEY, PRICE_KEY, QUANTITY_KEY, Product # noqa: F401 -from .utils import get_storage_str_representation # noqa: F401 - - -# TODO: задайте приглашение и текст справки (используйте своё решение части 3) -PROMPT: Final[str] = "" -HELP_TEXT: Final[str] = "" +from .storage import NAME_KEY, PRICE_KEY, QUANTITY_KEY, Product +from .utils import get_storage_str_representation + + +PROMPT: Final[str] = "admin> " +HELP_TEXT: Final[str] = ( + "Available commands:\n" + " help show this message\n" + " exit leave the console\n" + " show print the whole store as a table\n" + " create add a product, print its new id\n" + " read print the product with that id\n" + " update overwrite that product's fields\n" + " delete remove the product with that id\n" + "\n" + "For create and update the price and quantity are the last two words of the\n" + "line; everything before them is the product name, so it may contain spaces\n" + '(for example "Gibson SG Junior") and needs no quoting.' +) def show_help() -> None: - """Print the command reference to stdout. - - The text is the module-level :data:`HELP_TEXT` constant, printed as - is: a heading, one line per command with a short description, and a - note on how multi-word names are parsed. - """ - # TODO: реализуйте функцию (используйте своё решение части 3) + print(HELP_TEXT) def print_result(result: object) -> None: - """Print a CRUD result to stdout unless it is ``None``. - - Args: - result: The value returned by a CRUD operation. ``None`` means the - operation already reported its own failure, so nothing is - printed in that case. - """ - # TODO: реализуйте функцию (используйте своё решение части 3) + if result is not None: + print(result) def run_command( - storage: dict[str, Product], product_names: set[str], line: str + storage: dict[str, Product], + product_names: set[str], + line: str, ) -> bool: - """Parse one console line and carry out the command it names. - - Args: - storage: The product store shared across the session; mutated in - place by the ``create``, ``update`` and ``delete`` commands. - product_names: The normalised names already in ``storage``; kept - in sync by the ``create``, ``update`` and ``delete`` commands. - line: One line of console input, already stripped of surrounding - whitespace. - - Returns: - ``True`` to keep the read-eval-print loop running, or ``False`` - once the ``exit`` command has been seen. A line that is not a - known command prints a notice and still returns ``True``. - - Raises: - ValueError: If the quantity argument of a CRUD command does not - parse as a base-10 integer. - decimal.InvalidOperation: If the price argument of ``create`` or - ``update`` does not parse as a decimal number. - """ - # TODO: реализуйте функцию - return False + commands = line.split() + + match commands: + case ["help"]: + show_help() + return True + case ["exit"]: + return False + case ["show"]: + print_result(get_storage_str_representation(storage)) + return True + case ["read", product_id]: + print_result(read_product(storage, product_id)) + return True + case ["delete", product_id]: + print_result(delete_product(storage, product_names, product_id)) + return True + case ["update", product_id, *args] if len(args) >= 3: + name = " ".join(args[:-2]) + price = Decimal(args[-2]) + quantity = int(args[-1]) + print_result( + update_product( + storage, + product_names, + product_id, + {NAME_KEY: name, PRICE_KEY: price, QUANTITY_KEY: quantity}, + ) + ) + return True + case ["create", *args] if len(args) >= 3: + name = " ".join(args[:-2]) + price = Decimal(args[-2]) + quantity = int(args[-1]) + print_result( + create_product( + storage, + product_names, + {NAME_KEY: name, PRICE_KEY: price, QUANTITY_KEY: quantity}, + ) + ) + return True + case _: + print(f"{line!r} is not a command") + return True def main() -> None: - """Run the admin console until the ``exit`` command is entered. - - A single product store, and the set of normalised names it holds, are - created empty and kept in memory for the whole session. Each iteration - reads one line from stdin, strips its surrounding whitespace and hands - it to :func:`run_command`. A line that names a command but whose price - or quantity argument does not parse is caught here and reported - without stopping the loop; only ``exit`` ends it. - """ storage: dict[str, Product] = {} product_names: set[str] = set() running = True @@ -114,7 +99,6 @@ def main() -> None: try: running = run_command(storage, product_names, line) - except (ValueError, InvalidOperation): print(f"{line!r} names a command but its arguments are invalid") diff --git a/src/part4/storage.py b/src/part4/storage.py index 9acedf07..fe192215 100644 --- a/src/part4/storage.py +++ b/src/part4/storage.py @@ -1,45 +1,8 @@ -"""In-memory product store for the shop CRUD exercise. - -The store is deliberately primitive: a plain dictionary, with no -persistence and no schema enforcement. It maps a product's ``id`` -- a -UUID string assigned by the create operation in :mod:`src.part4.crud` --- to its :data:`Product` record -- a dictionary with the keys ``name``, -``price`` and ``quantity`` -- where: - -* the ``storage`` key itself -- unique string identifier, assigned by the - create operation in :mod:`src.part4.crud`; it is not duplicated - inside the record; -* ``name`` -- human-readable product name, unique across the store, held - in normalised form (see - :func:`src.part4.utils.normalize_product_name`); -* ``price`` -- price of a single unit, held as a :class:`~decimal.Decimal` - amount rounded to a fixed number of decimal places (see - :func:`src.part4.utils.normalize_price`) so that money is never - subject to binary floating-point error; -* ``quantity`` -- number of units currently in stock. - -Field names are exposed as ``*_KEY`` constants so callers never hard-code -the dictionary keys. - -Every caller that mutates the store also threads along a second -structure, a ``set[str]`` of the normalised names currently in use -- -see, for example, the ``product_names`` parameter of -:func:`src.part4.crud.create_product`. Keeping that name index as a -plain set passed next to ``storage``, rather than bundling the two into -an object, lets a name-uniqueness check become an O(1) membership test -against the set instead of a linear scan over ``storage.values()``. The -set must always mirror the normalised names present in ``storage``; the -functions in :mod:`src.part4.crud` keep the two in sync on every -successful create, update and delete. -""" - from typing import Any, Final type Product = dict[str, Any] -# Name of each field inside a Product record. -# TODO: задайте имена полей записи -NAME_KEY: Final = "" -PRICE_KEY: Final = "" -QUANTITY_KEY: Final = "" +NAME_KEY: Final = "name" +PRICE_KEY: Final = "price" +QUANTITY_KEY: Final = "quantity" diff --git a/src/part4/utils.py b/src/part4/utils.py index d2a940ea..0234b1c0 100644 --- a/src/part4/utils.py +++ b/src/part4/utils.py @@ -1,27 +1,7 @@ -"""Standalone helpers shared by the part4 storage and CRUD modules. - -Normalisation: - -* :func:`normalize_price` rounds a raw :class:`~decimal.Decimal` amount to - the fixed number of fractional digits (:data:`PRICE_PRECISION`) that - every stored price uses, keeping currency values free of binary - floating-point error. -* :func:`normalize_product_name` strips surrounding whitespace from a - product name, collapses every internal run of whitespace to a single - space and lower-cases it, giving every stored name a single canonical - form. - -Presentation: - -* :func:`get_storage_str_representation` renders the whole store as a - text table meant to be printed to a terminal; each column is sized to - the longest value it holds in that particular call. -""" - -from decimal import ROUND_HALF_UP, Decimal # noqa: F401 +from decimal import ROUND_HALF_UP, Decimal from typing import Final -from .storage import ( # noqa: F401 +from .storage import ( NAME_KEY, PRICE_KEY, QUANTITY_KEY, @@ -29,72 +9,45 @@ ) -# Number of fractional digits every stored price is rounded to. -# Quantisation step derived from PRICE_PRECISION, e.g. Decimal("0.01"). -# TODO: задайте число знаков после запятой и шаг квантования (используйте своё -# решение части 3) -PRICE_PRECISION: Final[int] = 0 -PRICE_STEP: Final = Decimal(0) +PRICE_PRECISION: Final[int] = 2 +PRICE_STEP: Final = Decimal(1).scaleb(-PRICE_PRECISION) -# Column headers of the table produced by get_storage_str_representation, -# left to right. The width of each column is not fixed here -- it is -# measured per call from the data (see the function). -# TODO: задайте заголовки столбцов таблицы (используйте своё решение части 3) -TABLE_HEADERS: Final[tuple[str, ...]] = () +TABLE_HEADERS: Final[tuple[str, ...]] = ("ID", "name", "price", "quantity") def normalize_price(price: Decimal) -> Decimal: - """Round a price to the precision every stored record uses. - - Args: - price: The raw price amount. - - Returns: - ``price`` quantised to :data:`PRICE_PRECISION` fractional digits, - with halves rounded up. - """ - # TODO: реализуйте функцию (используйте своё решение части 3) - return Decimal(0) + return Decimal(price.quantize(PRICE_STEP, rounding=ROUND_HALF_UP)) def normalize_product_name(name: str) -> str: - """Reduce a product name to the canonical form the store keeps. + return " ".join(name.lower().split()) - Args: - name: The raw product name. - Returns: - ``name`` with every leading and trailing whitespace character - removed, every internal run of whitespace (spaces, tabs and the - like) collapsed to a single space, and the rest lower-cased. For - example ``"abc def\tghi\tjkl"`` becomes ``"abc def ghi jkl"``. - The result is an empty string when ``name`` holds nothing but - whitespace. - """ - # TODO: реализуйте функцию (используйте своё решение части 3) - return "" +def product_row(product_id: str, product: Product) -> tuple[str, ...]: + return ( + product_id, + product[NAME_KEY], + str(product[PRICE_KEY]), + str(product[QUANTITY_KEY]), + ) -# TODO: при необходимости добавьте свои вспомогательные функции +def drawing_row(cells: tuple[str, ...], widths: tuple[int, ...]) -> str: + new_row = tuple(cell.ljust(width) for cell, width in zip(cells, widths)) + return "| " + " | ".join(new_row) + " |" def get_storage_str_representation(storage: dict[str, Product]) -> str: - """Render the product store as a text table with data-sized columns. - - The table has the columns named by :data:`TABLE_HEADERS` -- id, name, - price and quantity. Each column is made exactly as wide as the longest - value it carries in this call (its header counted), so the columns - line up when the string is printed to a terminal and no value is ever - truncated. - - Args: - storage: The product store to render. - - Returns: - A multi-line string: a header row, a dashed separator row, then - one row per product in ``storage``, in insertion order. When - ``storage`` is empty only the header and separator rows are - returned, sized to the header labels. - """ - # TODO: реализуйте функцию (используйте своё решение части 3) - return "" + rows = [TABLE_HEADERS] + [ + product_row(product_id, product) for product_id, product in storage.items() + ] + + widths_of_string = tuple( + max(len(row[i]) for row in rows) for i in range(len(TABLE_HEADERS)) + ) + + header = drawing_row(TABLE_HEADERS, widths_of_string) + sep_line = "|" + "|".join("-" * (width + 2) for width in widths_of_string) + "|" + + lines = [drawing_row(row, widths_of_string) for row in rows[1:]] + return "\n".join([header, sep_line] + lines)