From 43481b715823ff773d42ece2fa90b65a20d6fea2 Mon Sep 17 00:00:00 2001 From: BICSSA <157736361+BICSSA@users.noreply.github.com> Date: Mon, 21 Sep 2026 07:49:56 +0300 Subject: [PATCH 1/6] commit 1 task completed --- src/part1/constants.py | 16 +++++++------- src/part1/snowflake.py | 49 +++++++++++++++++++++++++++++++----------- 2 files changed, 45 insertions(+), 20 deletions(-) diff --git a/src/part1/constants.py b/src/part1/constants.py index 9abfbba2..7a112a77 100644 --- a/src/part1/constants.py +++ b/src/part1/constants.py @@ -19,20 +19,20 @@ # Все константы, зависящие от ёмкостей *_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] = 2**TIMESTAMP_BITS - 1 +NODE_ID_MAX: Final[int] = 2**NODE_ID_BITS - 1 +SEQUENCE_ID_MAX: Final[int] = 2**SEQUENCE_ID_BITS - 1 # Здесь можно добавить собственные вспомогательные константы # (например, сдвиги полей при сборке идентификатора). diff --git a/src/part1/snowflake.py b/src/part1/snowflake.py index d3abf050..33b6754b 100644 --- a/src/part1/snowflake.py +++ b/src/part1/snowflake.py @@ -13,12 +13,14 @@ :func:`decode_node_id` and :func:`decode_sequence_id`. """ -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, ) @@ -34,8 +36,8 @@ def read_current_millis(epoch_ms: int) -> int: The count of whole milliseconds between ``epoch_ms`` and now. May be negative if ``epoch_ms`` lies in the future. """ - # TODO: реализуйте функцию - return 0 + current_ms = time.time_ns() // 1_000_000 + return current_ms - epoch_ms def decode_timestamp_ms(snowflake_id: int, epoch_ms: int = EPOCH_MS_DEFAULT) -> int: @@ -50,8 +52,10 @@ def decode_timestamp_ms(snowflake_id: int, epoch_ms: int = EPOCH_MS_DEFAULT) -> The absolute Unix time in milliseconds at which the identifier was generated. """ - # TODO: реализуйте функцию - return 0 + bits_shift = NODE_ID_BITS + SEQUENCE_ID_BITS + timestamp_part = snowflake_id >> bits_shift + + return timestamp_part + epoch_ms def decode_node_id(snowflake_id: int) -> int: @@ -64,8 +68,10 @@ def decode_node_id(snowflake_id: int) -> int: The node identifier packed into ``snowflake_id``, in the range ``[0, NODE_ID_MAX]``. """ - # TODO: реализуйте функцию - return 0 + bits_mask = (1 << NODE_ID_BITS) - 1 + node_id = (snowflake_id >> SEQUENCE_ID_BITS) & bits_mask + + return node_id def decode_sequence_id(snowflake_id: int) -> int: @@ -78,8 +84,9 @@ def decode_sequence_id(snowflake_id: int) -> int: The per-millisecond sequence counter packed into ``snowflake_id``, in the range ``[0, SEQUENCE_ID_MAX]``. """ - # TODO: реализуйте функцию - return 0 + bits_mask = (1 << SEQUENCE_ID_BITS) - 1 + + return snowflake_id & bits_mask def generate_snowflake_id( @@ -110,5 +117,23 @@ def generate_snowflake_id( 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 node_id < 0 or node_id > NODE_ID_MAX: + print(f"node_id must be in [0, {NODE_ID_MAX}], got {node_id}") + return None + + if sequence_id < 0 or sequence_id > SEQUENCE_ID_MAX: + print(f"sequence_id must be in [0, {SEQUENCE_ID_MAX}], got {sequence_id}") + return None + + current_millis = read_current_millis(epoch_ms) + if current_millis > TIMESTAMP_MS_MAX: + print("TIMESTAMP_MS_MAX overflows") + return None + + snowflake_id = ( + (current_millis << (SEQUENCE_ID_BITS + NODE_ID_BITS)) + | (node_id << SEQUENCE_ID_BITS) + | sequence_id + ) + + return snowflake_id From 20f719ba9ee8f5b31062f5c41b483338dcd90868 Mon Sep 17 00:00:00 2001 From: BICSSA <157736361+BICSSA@users.noreply.github.com> Date: Mon, 28 Sep 2026 08:00:11 +0300 Subject: [PATCH 2/6] Task 2 Final version Task 2 --- src/part2/TASK.md | 2 +- src/part2/cart.py | 113 +++++++++++++++++++++-- src/part2/crud.py | 73 ++++++++++++--- src/part2/storage.py | 10 +-- src/part2/utils.py | 10 +-- test.py | 208 +++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 383 insertions(+), 33 deletions(-) create mode 100644 test.py diff --git a/src/part2/TASK.md b/src/part2/TASK.md index 25736d9c..36a83116 100644 --- a/src/part2/TASK.md +++ b/src/part2/TASK.md @@ -187,7 +187,7 @@ delete) над единым хранилищем, аккуратная рабо печатается сообщение об ошибке, содержащее идентификатор (например: `product is not in the cart`), возвращается `None`, ничего не меняется. 2. Иначе количество в строке корзины сравнивается с запрошенным. Если в корзине - строго меньше, чем `quantity` — печатается сообщение об ошибке с + строго меньше, чем `quantity` — печатается сообщение об ошибке с идентификатором (например: `cart holds only <в корзине> unit(s) of product , cannot remove `), возвращается `None`, ничего не меняется. diff --git a/src/part2/cart.py b/src/part2/cart.py index 063f9aea..1dadded1 100644 --- a/src/part2/cart.py +++ b/src/part2/cart.py @@ -11,8 +11,8 @@ 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 +24,7 @@ # TODO: задайте позиции полей внутри кортежа CartLine LINE_PRODUCT_ID_INDEX: Final = 0 -LINE_QUANTITY_INDEX: Final = 0 +LINE_QUANTITY_INDEX: Final = 1 def add_to_cart( @@ -53,9 +53,84 @@ def add_to_cart( 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) + product = read_product(storage, product_id) + if not product: + return None + if product[QUANTITY_INDEX] < quantity: + print( + f"not enough stock for product {product_id}: storage available, {product[QUANTITY_INDEX]} requested" + ) + + return None + + update_product( + storage, + product_id, + (product[NAME_INDEX], product[PRICE_INDEX], product[QUANTITY_INDEX] - quantity), + ) + + + for index_cart_line in range(len(cart)): + if cart[index_cart_line][LINE_PRODUCT_ID_INDEX] == product_id: + cart[index_cart_line] = ( + product_id, + quantity + cart[index_cart_line][LINE_QUANTITY_INDEX], + ) + return cart[index_cart_line] + + cart.append((product_id, quantity)) + return (product_id, quantity) + +def find_cart_line(cart: list[CartLine], product_id: int) -> CartLine | None: + """Find line of the product from cart + + Find first entry in cart line with necassery product_id. + + Args: + cart: user's shopping cart + product_id: The identifier of the product to find. + + Returns: + cart_line if all correct + `None` if identifier of the product don't found + """ + for cart_line in cart: + if cart_line[LINE_PRODUCT_ID_INDEX] == product_id: + return cart_line + + print(f"product {product_id} is not in the cart") + return None + +def update_cart_line( + cart: list[CartLine], product_id: int, quantity: int +) -> CartLine | None: + """Update line of the product in the cart + + If quantity = 0 line in the cart is remove. Else his quantity update. + + Args: + cart: user's shopping cart + product_id: The identifier of the product to find. + quantity: New product quantity value + + Returns: + cart_line if all correct + `None` if identifier of the product don't found + """ + for index_cart_line in range(len(cart)): + if cart[index_cart_line][LINE_PRODUCT_ID_INDEX] == product_id: + + if quantity == 0: + del cart[index_cart_line] + else: + cart[index_cart_line] = (product_id, quantity) + + return (product_id, quantity) + + print(f"product {product_id} is not in the cart") + return None + def remove_from_cart( storage: list[Product], @@ -85,5 +160,29 @@ def remove_from_cart( 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) + cart_line = find_cart_line(cart, product_id) + if not cart_line: + return None + + if cart[LINE_QUANTITY_INDEX] < quantity: + print( + f"cart holds only in cart unit(s) of product {product_id}, cannot remove {quantity}" + ) + + return None + + product = read_product(storage, product_id) + if not product: + return None + + update_product( + storage, + product_id, + (product[NAME_INDEX], product[PRICE_INDEX], product[QUANTITY_INDEX] + quantity), + ) + + new_cart_line = update_cart_line( + cart, product_id, cart_line[LINE_QUANTITY_INDEX] - quantity + ) + + return new_cart_line diff --git a/src/part2/crud.py b/src/part2/crud.py index d026cbcb..44b4b490 100644 --- a/src/part2/crud.py +++ b/src/part2/crud.py @@ -14,13 +14,14 @@ from decimal import Decimal -from .storage import ( # noqa: F401 +from .storage import ( NAME_INDEX, PRODUCT_ID_INDEX, PRODUCT_ID_MIN, + QUANTITY_INDEX, Product, ) -from .utils import normalize_price # noqa: F401 +from .utils import normalize_price def generate_product_id(storage: list[Product]) -> int: @@ -34,8 +35,10 @@ def generate_product_id(storage: list[Product]) -> int: :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( @@ -56,8 +59,18 @@ def create_product( ``storage`` is left unchanged and a message naming the clashing name is printed. """ - # TODO: реализуйте функцию - return 0 + if any(fields[NAME_INDEX - 1] == product[NAME_INDEX] for product in storage): + print(f"product name {fields[NAME_INDEX - 1]} is already taken") + return None + + new_id = generate_product_id() + new_price = normalize_price(fields[NAME_INDEX - 1]) + + storage.append( + (new_id, fields[NAME_INDEX - 1], new_price, fields[QUANTITY_INDEX - 1]) + ) + + return new_id def read_product(storage: list[Product], product_id: int) -> Product | None: @@ -72,8 +85,12 @@ def read_product(storage: list[Product], product_id: int) -> Product | None: ``None`` when no product carries that identifier (a message is printed in that case). """ - # TODO: реализуйте функцию - return (0, "", Decimal(0), 0) + 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( @@ -97,10 +114,34 @@ def update_product( 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). + left unchanged and a message is printed). Also ``None`` when + product name is already taken. """ - # TODO: реализуйте функцию - return (0, "", Decimal(0), 0) + index_modifiable_product = -1 + + for index in range(len(storage)): + if storage[index][NAME_INDEX] == fields[NAME_INDEX - 1]: + print(f"product name {fields[NAME_INDEX - 1]} is already taken") + return None + + if storage[index][PRODUCT_ID_INDEX] == product_id: + index_modifiable_product = index + + if index_modifiable_product == -1: + print(f"no product with id {product_id}") + return None + + new_price = normalize_price(fields[NAME_INDEX - 1]) + + storage[index_modifiable_product] = ( + product_id, + fields[NAME_INDEX - 1], + new_price, + fields[QUANTITY_INDEX - 1], + ) + + return storage[index_modifiable_product] + def delete_product(storage: list[Product], product_id: int) -> int | None: @@ -116,5 +157,11 @@ def delete_product(storage: list[Product], product_id: int) -> int | None: product carried that identifier (``storage`` is left unchanged and a message is printed). """ - # TODO: реализуйте функцию - return 0 + for i, product in enumerate(storage): + if product[PRODUCT_ID_INDEX] == product_id: + del storage[i] + return product + + 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..e4bceff1 100644 --- a/src/part2/storage.py +++ b/src/part2/storage.py @@ -24,11 +24,9 @@ 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..d848125d 100644 --- a/src/part2/utils.py +++ b/src/part2/utils.py @@ -6,13 +6,12 @@ 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: @@ -25,5 +24,4 @@ def normalize_price(price: Decimal) -> Decimal: ``price`` quantised to :data:`PRICE_PRECISION` fractional digits, with halves rounded up. """ - # TODO: реализуйте функцию - return Decimal(0) + return price.quantize(PRICE_STEP, rounding=ROUND_HALF_UP) diff --git a/test.py b/test.py new file mode 100644 index 00000000..7a5b9c4e --- /dev/null +++ b/test.py @@ -0,0 +1,208 @@ +from decimal import Decimal + +import pytest + +from src.part2 import cart, crud, storage, utils + + +def test_normalize_price_examples(): + assert utils.normalize_price(Decimal("12.999")) == Decimal("13.00") + assert utils.normalize_price(Decimal("2.3451")) == Decimal("2.35") + assert utils.normalize_price(Decimal("2.3449")) == Decimal("2.34") + assert utils.normalize_price(Decimal("5")) == Decimal("5.00") + + +def test_generate_product_id(): + assert crud.generate_product_id([]) == storage.PRODUCT_ID_MIN + + st = [ + (1, "A", Decimal("1.00"), 1), + (7, "B", Decimal("2.00"), 2), + ] + assert crud.generate_product_id(st) == 8 + + +def test_create_product(): + st = [] + pid = crud.create_product(st, ("Apple", Decimal("2.345"), 10)) + + assert pid == 1 + assert st == [(1, "Apple", Decimal("2.35"), 10)] + + +def test_create_product_duplicate_name(capsys): + st = [(1, "Apple", Decimal("1.00"), 1)] + + assert crud.create_product(st, ("Apple", Decimal("2.00"), 2)) is None + assert st == [(1, "Apple", Decimal("1.00"), 1)] + + out = capsys.readouterr().out + assert "Apple" in out + + +def test_read_product(capsys): + st = [(1, "Apple", Decimal("1.00"), 1)] + + assert crud.read_product(st, 1) == (1, "Apple", Decimal("1.00"), 1) + assert crud.read_product(st, 99) is None + + out = capsys.readouterr().out + assert "99" in out + + +def test_update_product_same_name_and_normalize(): + st = [ + (1, "Apple", Decimal("1.00"), 1), + (2, "Banana", Decimal("2.00"), 2), + ] + + res = crud.update_product(st, 1, ("Apple", Decimal("3.456"), 5)) + + assert res == (1, "Apple", Decimal("3.46"), 5) + assert st[0] == (1, "Apple", Decimal("3.46"), 5) + + +def test_update_product_allows_duplicate_name(): + st = [ + (1, "Apple", Decimal("1.00"), 1), + (2, "Banana", Decimal("2.00"), 2), + ] + + res = crud.update_product(st, 1, ("Banana", Decimal("3.00"), 3)) + + assert res == (1, "Banana", Decimal("3.00"), 3) + + +def test_update_product_missing(capsys): + st = [(1, "Apple", Decimal("1.00"), 1)] + + assert crud.update_product(st, 99, ("X", Decimal("1.00"), 1)) is None + assert "99" in capsys.readouterr().out + + +def test_delete_product_returns_id(): + st = [ + (1, "Apple", Decimal("1.00"), 1), + (2, "Banana", Decimal("2.00"), 2), + ] + + assert crud.delete_product(st, 2) == 2 + assert st == [(1, "Apple", Decimal("1.00"), 1)] + + +def test_delete_product_missing(capsys): + st = [] + + assert crud.delete_product(st, 99) is None + assert "99" in capsys.readouterr().out + + +def make_storage(): + return [ + (1, "Apple", Decimal("1.00"), 10), + (2, "Banana", Decimal("2.00"), 5), + ] + + +def test_add_to_cart_new_line(): + st = make_storage() + c = [] + + assert cart.add_to_cart(st, c, 1, 3) == (1, 3) + assert c == [(1, 3)] + assert st[0][3] == 7 + + +def test_add_to_cart_existing_line(): + st = make_storage() + c = [(1, 2)] + + assert cart.add_to_cart(st, c, 1, 3) == (1, 5) + assert c == [(1, 5)] + assert st[0][3] == 7 + + +def test_add_to_cart_not_enough(capsys): + st = make_storage() + c = [] + + assert cart.add_to_cart(st, c, 1, 11) is None + assert c == [] + assert st[0][3] == 10 + + out = capsys.readouterr().out + assert "1" in out + assert "10" in out + assert "11" in out + + +def test_add_to_cart_unknown(capsys): + st = make_storage() + c = [] + + assert cart.add_to_cart(st, c, 99, 1) is None + assert c == [] + assert "99" in capsys.readouterr().out + + +def test_remove_from_cart_partial(): + st = make_storage() + c = [(1, 5)] + + assert cart.remove_from_cart(st, c, 1, 2) == (1, 3) + assert c == [(1, 3)] + assert st[0][3] == 12 + + +def test_remove_from_cart_full(): + st = make_storage() + c = [(1, 3)] + + assert cart.remove_from_cart(st, c, 1, 3) == (1, 0) + assert c == [] + assert st[0][3] == 13 + + +def test_remove_from_cart_not_in_cart(capsys): + st = make_storage() + c = [] + + assert cart.remove_from_cart(st, c, 1, 1) is None + assert c == [] + assert "1" in capsys.readouterr().out + + +def test_remove_from_cart_too_many(capsys): + st = make_storage() + c = [(1, 2)] + + assert cart.remove_from_cart(st, c, 1, 3) is None + assert c == [(1, 2)] + assert st[0][3] == 10 + + out = capsys.readouterr().out + assert "1" in out + assert "2" in out + assert "3" in out + + +def test_remove_from_cart_product_missing_from_storage(capsys): + st = [] + c = [(1, 2)] + + assert cart.remove_from_cart(st, c, 1, 1) is None + assert c == [(1, 2)] + assert "1" in capsys.readouterr().out + + +def test_cart_storage_balance_invariant(): + st = make_storage() + c = [] + + total = st[0][3] + + cart.add_to_cart(st, c, 1, 4) + assert st[0][3] + c[0][1] == total + + cart.remove_from_cart(st, c, 1, 2) + assert st[0][3] + c[0][1] == total \ No newline at end of file From 720cb1d63be80a70060bb482d7c517b5d4452d3d Mon Sep 17 00:00:00 2001 From: BICSSA <157736361+BICSSA@users.noreply.github.com> Date: Mon, 28 Sep 2026 08:01:52 +0300 Subject: [PATCH 3/6] Delete test.py --- test.py | 208 -------------------------------------------------------- 1 file changed, 208 deletions(-) delete mode 100644 test.py diff --git a/test.py b/test.py deleted file mode 100644 index 7a5b9c4e..00000000 --- a/test.py +++ /dev/null @@ -1,208 +0,0 @@ -from decimal import Decimal - -import pytest - -from src.part2 import cart, crud, storage, utils - - -def test_normalize_price_examples(): - assert utils.normalize_price(Decimal("12.999")) == Decimal("13.00") - assert utils.normalize_price(Decimal("2.3451")) == Decimal("2.35") - assert utils.normalize_price(Decimal("2.3449")) == Decimal("2.34") - assert utils.normalize_price(Decimal("5")) == Decimal("5.00") - - -def test_generate_product_id(): - assert crud.generate_product_id([]) == storage.PRODUCT_ID_MIN - - st = [ - (1, "A", Decimal("1.00"), 1), - (7, "B", Decimal("2.00"), 2), - ] - assert crud.generate_product_id(st) == 8 - - -def test_create_product(): - st = [] - pid = crud.create_product(st, ("Apple", Decimal("2.345"), 10)) - - assert pid == 1 - assert st == [(1, "Apple", Decimal("2.35"), 10)] - - -def test_create_product_duplicate_name(capsys): - st = [(1, "Apple", Decimal("1.00"), 1)] - - assert crud.create_product(st, ("Apple", Decimal("2.00"), 2)) is None - assert st == [(1, "Apple", Decimal("1.00"), 1)] - - out = capsys.readouterr().out - assert "Apple" in out - - -def test_read_product(capsys): - st = [(1, "Apple", Decimal("1.00"), 1)] - - assert crud.read_product(st, 1) == (1, "Apple", Decimal("1.00"), 1) - assert crud.read_product(st, 99) is None - - out = capsys.readouterr().out - assert "99" in out - - -def test_update_product_same_name_and_normalize(): - st = [ - (1, "Apple", Decimal("1.00"), 1), - (2, "Banana", Decimal("2.00"), 2), - ] - - res = crud.update_product(st, 1, ("Apple", Decimal("3.456"), 5)) - - assert res == (1, "Apple", Decimal("3.46"), 5) - assert st[0] == (1, "Apple", Decimal("3.46"), 5) - - -def test_update_product_allows_duplicate_name(): - st = [ - (1, "Apple", Decimal("1.00"), 1), - (2, "Banana", Decimal("2.00"), 2), - ] - - res = crud.update_product(st, 1, ("Banana", Decimal("3.00"), 3)) - - assert res == (1, "Banana", Decimal("3.00"), 3) - - -def test_update_product_missing(capsys): - st = [(1, "Apple", Decimal("1.00"), 1)] - - assert crud.update_product(st, 99, ("X", Decimal("1.00"), 1)) is None - assert "99" in capsys.readouterr().out - - -def test_delete_product_returns_id(): - st = [ - (1, "Apple", Decimal("1.00"), 1), - (2, "Banana", Decimal("2.00"), 2), - ] - - assert crud.delete_product(st, 2) == 2 - assert st == [(1, "Apple", Decimal("1.00"), 1)] - - -def test_delete_product_missing(capsys): - st = [] - - assert crud.delete_product(st, 99) is None - assert "99" in capsys.readouterr().out - - -def make_storage(): - return [ - (1, "Apple", Decimal("1.00"), 10), - (2, "Banana", Decimal("2.00"), 5), - ] - - -def test_add_to_cart_new_line(): - st = make_storage() - c = [] - - assert cart.add_to_cart(st, c, 1, 3) == (1, 3) - assert c == [(1, 3)] - assert st[0][3] == 7 - - -def test_add_to_cart_existing_line(): - st = make_storage() - c = [(1, 2)] - - assert cart.add_to_cart(st, c, 1, 3) == (1, 5) - assert c == [(1, 5)] - assert st[0][3] == 7 - - -def test_add_to_cart_not_enough(capsys): - st = make_storage() - c = [] - - assert cart.add_to_cart(st, c, 1, 11) is None - assert c == [] - assert st[0][3] == 10 - - out = capsys.readouterr().out - assert "1" in out - assert "10" in out - assert "11" in out - - -def test_add_to_cart_unknown(capsys): - st = make_storage() - c = [] - - assert cart.add_to_cart(st, c, 99, 1) is None - assert c == [] - assert "99" in capsys.readouterr().out - - -def test_remove_from_cart_partial(): - st = make_storage() - c = [(1, 5)] - - assert cart.remove_from_cart(st, c, 1, 2) == (1, 3) - assert c == [(1, 3)] - assert st[0][3] == 12 - - -def test_remove_from_cart_full(): - st = make_storage() - c = [(1, 3)] - - assert cart.remove_from_cart(st, c, 1, 3) == (1, 0) - assert c == [] - assert st[0][3] == 13 - - -def test_remove_from_cart_not_in_cart(capsys): - st = make_storage() - c = [] - - assert cart.remove_from_cart(st, c, 1, 1) is None - assert c == [] - assert "1" in capsys.readouterr().out - - -def test_remove_from_cart_too_many(capsys): - st = make_storage() - c = [(1, 2)] - - assert cart.remove_from_cart(st, c, 1, 3) is None - assert c == [(1, 2)] - assert st[0][3] == 10 - - out = capsys.readouterr().out - assert "1" in out - assert "2" in out - assert "3" in out - - -def test_remove_from_cart_product_missing_from_storage(capsys): - st = [] - c = [(1, 2)] - - assert cart.remove_from_cart(st, c, 1, 1) is None - assert c == [(1, 2)] - assert "1" in capsys.readouterr().out - - -def test_cart_storage_balance_invariant(): - st = make_storage() - c = [] - - total = st[0][3] - - cart.add_to_cart(st, c, 1, 4) - assert st[0][3] + c[0][1] == total - - cart.remove_from_cart(st, c, 1, 2) - assert st[0][3] + c[0][1] == total \ No newline at end of file From 9154e92ae37dec90bc28ac7d6d812ff26e7b0a64 Mon Sep 17 00:00:00 2001 From: BICSSA <157736361+BICSSA@users.noreply.github.com> Date: Mon, 28 Sep 2026 08:20:11 +0300 Subject: [PATCH 4/6] Task 2 Already final version --- src/part2/cart.py | 18 +++++++++--------- src/part2/crud.py | 30 +++++++++++++++--------------- src/part2/storage.py | 4 ++++ 3 files changed, 28 insertions(+), 24 deletions(-) diff --git a/src/part2/cart.py b/src/part2/cart.py index 1dadded1..ec0c871a 100644 --- a/src/part2/cart.py +++ b/src/part2/cart.py @@ -70,7 +70,6 @@ def add_to_cart( (product[NAME_INDEX], product[PRICE_INDEX], product[QUANTITY_INDEX] - quantity), ) - for index_cart_line in range(len(cart)): if cart[index_cart_line][LINE_PRODUCT_ID_INDEX] == product_id: cart[index_cart_line] = ( @@ -82,6 +81,7 @@ def add_to_cart( cart.append((product_id, quantity)) return (product_id, quantity) + def find_cart_line(cart: list[CartLine], product_id: int) -> CartLine | None: """Find line of the product from cart @@ -90,7 +90,7 @@ def find_cart_line(cart: list[CartLine], product_id: int) -> CartLine | None: Args: cart: user's shopping cart product_id: The identifier of the product to find. - + Returns: cart_line if all correct `None` if identifier of the product don't found @@ -98,10 +98,11 @@ def find_cart_line(cart: list[CartLine], product_id: int) -> CartLine | None: for cart_line in cart: if cart_line[LINE_PRODUCT_ID_INDEX] == product_id: return cart_line - + print(f"product {product_id} is not in the cart") return None + def update_cart_line( cart: list[CartLine], product_id: int, quantity: int ) -> CartLine | None: @@ -113,24 +114,22 @@ def update_cart_line( cart: user's shopping cart product_id: The identifier of the product to find. quantity: New product quantity value - + Returns: cart_line if all correct `None` if identifier of the product don't found """ for index_cart_line in range(len(cart)): if cart[index_cart_line][LINE_PRODUCT_ID_INDEX] == product_id: - if quantity == 0: del cart[index_cart_line] else: cart[index_cart_line] = (product_id, quantity) - return (product_id, quantity) print(f"product {product_id} is not in the cart") return None - + def remove_from_cart( storage: list[Product], @@ -164,9 +163,10 @@ def remove_from_cart( if not cart_line: return None - if cart[LINE_QUANTITY_INDEX] < quantity: + if cart_line[LINE_QUANTITY_INDEX] < quantity: print( - f"cart holds only in cart unit(s) of product {product_id}, cannot remove {quantity}" + f"cart holds only {cart_line[LINE_QUANTITY_INDEX]} unit(s) " + f"of product {product_id}, cannot remove {quantity}" ) return None diff --git a/src/part2/crud.py b/src/part2/crud.py index 44b4b490..48c0ea56 100644 --- a/src/part2/crud.py +++ b/src/part2/crud.py @@ -15,10 +15,12 @@ from decimal import Decimal from .storage import ( + FIELDS_NAME_INDEX, + FIELDS_PRICE_INDEX, + FIELDS_QUANTITY_INDEX, NAME_INDEX, PRODUCT_ID_INDEX, PRODUCT_ID_MIN, - QUANTITY_INDEX, Product, ) from .utils import normalize_price @@ -59,15 +61,15 @@ def create_product( ``storage`` is left unchanged and a message naming the clashing name is printed. """ - if any(fields[NAME_INDEX - 1] == product[NAME_INDEX] for product in storage): - print(f"product name {fields[NAME_INDEX - 1]} is already taken") + if any(fields[FIELDS_NAME_INDEX] == product[NAME_INDEX] for product in storage): + print(f"product name {fields[FIELDS_NAME_INDEX]} is already taken") return None - new_id = generate_product_id() - new_price = normalize_price(fields[NAME_INDEX - 1]) + new_id = generate_product_id(storage) + new_price = normalize_price(fields[FIELDS_PRICE_INDEX]) storage.append( - (new_id, fields[NAME_INDEX - 1], new_price, fields[QUANTITY_INDEX - 1]) + (new_id, fields[FIELDS_NAME_INDEX], new_price, fields[FIELDS_QUANTITY_INDEX]) ) return new_id @@ -120,8 +122,8 @@ def update_product( index_modifiable_product = -1 for index in range(len(storage)): - if storage[index][NAME_INDEX] == fields[NAME_INDEX - 1]: - print(f"product name {fields[NAME_INDEX - 1]} is already taken") + if storage[index][NAME_INDEX] == fields[FIELDS_NAME_INDEX]: + print(f"product name {fields[FIELDS_NAME_INDEX]} is already taken") return None if storage[index][PRODUCT_ID_INDEX] == product_id: @@ -131,17 +133,16 @@ def update_product( print(f"no product with id {product_id}") return None - new_price = normalize_price(fields[NAME_INDEX - 1]) + new_price = normalize_price(fields[FIELDS_PRICE_INDEX]) storage[index_modifiable_product] = ( product_id, - fields[NAME_INDEX - 1], + fields[FIELDS_NAME_INDEX], new_price, - fields[QUANTITY_INDEX - 1], + fields[FIELDS_QUANTITY_INDEX], ) return storage[index_modifiable_product] - def delete_product(storage: list[Product], product_id: int) -> int | None: @@ -160,8 +161,7 @@ def delete_product(storage: list[Product], product_id: int) -> int | None: for i, product in enumerate(storage): if product[PRODUCT_ID_INDEX] == product_id: del storage[i] - return product + return product_id print(f"no product with id {product_id}") - - return None \ No newline at end of file + return None diff --git a/src/part2/storage.py b/src/part2/storage.py index e4bceff1..b41efe15 100644 --- a/src/part2/storage.py +++ b/src/part2/storage.py @@ -29,4 +29,8 @@ PRICE_INDEX: Final = 2 QUANTITY_INDEX: Final = 3 +FIELDS_NAME_INDEX: Final = 0 +FIELDS_PRICE_INDEX: Final = 1 +FIELDS_QUANTITY_INDEX: Final = 2 + PRODUCT_ID_MIN: Final[int] = 1 From 1af7d316b134f5089c7d89ba3f12fa9de237029c Mon Sep 17 00:00:00 2001 From: BICSSA <157736361+BICSSA@users.noreply.github.com> Date: Mon, 5 Oct 2026 20:01:12 +0300 Subject: [PATCH 5/6] Task Compl --- src/part3/crud.py | 64 ++++++++++++++++++++++++++++++------- src/part3/run_admin.py | 71 ++++++++++++++++++++++++++++++++++++------ src/part3/storage.py | 19 +++++------ src/part3/utils.py | 63 ++++++++++++++++++++++++++++--------- 4 files changed, 172 insertions(+), 45 deletions(-) diff --git a/src/part3/crud.py b/src/part3/crud.py index 68811d7e..fc9ad784 100644 --- a/src/part3/crud.py +++ b/src/part3/crud.py @@ -20,13 +20,13 @@ 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, normalize_product_name # noqa: F401 +from .utils import normalize_price, normalize_product_name def generate_product_id(storage: list[Product]) -> int: @@ -40,8 +40,10 @@ def generate_product_id(storage: list[Product]) -> int: :data:`~src.part3.storage.PRODUCT_ID_MIN` when ``storage`` is empty. """ - # TODO: реализуйте функцию (используйте своё решение части 2) - return 0 + if not storage: + return PRODUCT_ID_MIN + + return max(product[PRODUCT_ID_INDEX] for product in storage) + 1 def create_product( @@ -64,8 +66,21 @@ def create_product( normalised name already exists. In the ``None`` case ``storage`` is left unchanged and an explanatory message is printed. """ - # TODO: реализуйте функцию - return 0 + name, price, quantity = fields + name = normalize_product_name(name) + + if not name: + print("product name must not be blank") + return None + + for product in storage: + if product[NAME_INDEX] == name: + print(f"product name '{name}' is already taken") + return None + + product_id = generate_product_id(storage) + storage.append((product_id, name, normalize_price(price), quantity)) + return product_id def read_product(storage: list[Product], product_id: int) -> Product | None: @@ -80,8 +95,12 @@ def read_product(storage: list[Product], product_id: int) -> Product | None: ``None`` when no product carries that identifier (a message is printed in that case). """ - # TODO: реализуйте функцию (используйте своё решение части 2) - return (0, "", Decimal(0), 0) + 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( @@ -110,8 +129,25 @@ def update_product( unchanged and an explanatory message is printed. Renaming a product to its own current name is allowed. """ - # TODO: реализуйте функцию - return (0, "", Decimal(0), 0) + name, price, quantity = fields + name = normalize_product_name(name) + + if not name: + print("product name must not be blank") + return None + + existing_product = read_product(storage, product_id) + if existing_product is None: + return None + + for product in storage: + if product[NAME_INDEX] == name and product[PRODUCT_ID_INDEX] != product_id: + print(f"product name '{name}' is already taken") + return None + + product = (product_id, name, normalize_price(price), quantity) + storage[storage.index(existing_product)] = product + return product def delete_product(storage: list[Product], product_id: int) -> int | None: @@ -127,5 +163,9 @@ def delete_product(storage: list[Product], product_id: int) -> int | None: product carried that identifier (``storage`` is left unchanged and a message is printed). """ - # TODO: реализуйте функцию (используйте своё решение части 2) - return 0 + product = read_product(storage, product_id) + if product is None: + return None + + storage.remove(product) + return product_id diff --git a/src/part3/run_admin.py b/src/part3/run_admin.py index c5feeb0b..5b0bcf68 100644 --- a/src/part3/run_admin.py +++ b/src/part3/run_admin.py @@ -29,22 +29,32 @@ 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 Product -from .utils import get_storage_str_representation # noqa: F401 +from .utils import get_storage_str_representation -# TODO: задайте приглашение и текст справки -PROMPT: Final[str] = "" -HELP_TEXT: Final[str] = "" +PROMPT: Final[str] = "admin> " +HELP_TEXT: Final[str] = """Available commands: + help show this message + exit leave the console + show print the whole store as a table + create add a product, print its new id + read print the product with that id + update overwrite that product's fields + delete remove the product with that id + +For create and update the price and quantity are the last two words of the +line; everything before them is the product name, so it may contain spaces +(for example "Gibson SG Junior") and needs no quoting.""" def show_help() -> None: @@ -54,7 +64,7 @@ def show_help() -> None: is: a heading, one line per command with a short description, and a note on how multi-word names are parsed. """ - # TODO: реализуйте функцию + print(HELP_TEXT) def print_result(result: object) -> None: @@ -65,7 +75,8 @@ def print_result(result: object) -> None: operation already reported its own failure, so nothing is printed in that case. """ - # TODO: реализуйте функцию + if result is not None: + print(result) def run_command(storage: list[Product], line: str) -> bool: @@ -88,8 +99,48 @@ def run_command(storage: list[Product], line: str) -> bool: decimal.InvalidOperation: If the price argument of ``create`` or ``update`` does not parse as a decimal number. """ - # TODO: реализуйте функцию - return False + + match line.split(): + case ["help"]: + show_help() + return True + + case ["exit"]: + return False + + case ["show"]: + print_result(get_storage_str_representation(storage)) + return True + + case ["read", id]: + print_result(read_product(storage, int(id))) + return True + + case ["delete", id]: + print_result(delete_product(storage, int(id))) + return True + + case ["create", *name, price, quantity]: + if not name: + print(f"'{line}' is not a command") + return True + + fields = (" ".join(name), Decimal(price), int(quantity)) + print_result(create_product(storage, fields)) + return True + + case ["update", id, *name, price, quantity]: + if not name: + print(f"'{line}' is not a command") + return True + + fields = (" ".join(name), Decimal(price), int(quantity)) + print_result(update_product(storage, int(id), fields)) + return True + + case _: + print(f"'{line}' is not a command") + return True def main() -> None: diff --git a/src/part3/storage.py b/src/part3/storage.py index c5e34be5..b41efe15 100644 --- a/src/part3/storage.py +++ b/src/part3/storage.py @@ -6,11 +6,11 @@ where: * ``product_id`` -- unique positive integer key, assigned by the create - operation in :mod:`src.part3.crud`; + 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.part3.utils.normalize_price`) so that money is never + :func:`src.part2.utils.normalize_price`) so that money is never subject to binary floating-point error; * ``quantity`` -- number of units currently in stock. @@ -24,12 +24,13 @@ type Product = tuple[int, str, Decimal, int] -# TODO: задайте позиции полей внутри кортежа Product (используйте своё решение -# части 2) 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 +FIELDS_NAME_INDEX: Final = 0 +FIELDS_PRICE_INDEX: Final = 1 +FIELDS_QUANTITY_INDEX: Final = 2 + +PRODUCT_ID_MIN: Final[int] = 1 diff --git a/src/part3/utils.py b/src/part3/utils.py index 318ded0b..3a1d943e 100644 --- a/src/part3/utils.py +++ b/src/part3/utils.py @@ -18,7 +18,7 @@ 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 Product @@ -26,16 +26,13 @@ # Number of fractional digits every stored price is rounded to. # Quantisation step derived from PRICE_PRECISION, e.g. Decimal("0.01"). -# TODO: задайте число знаков после запятой и шаг квантования (используйте своё -# решение части 2) -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: задайте заголовки столбцов таблицы -TABLE_HEADERS: Final[tuple[str, ...]] = () +TABLE_HEADERS: Final[tuple[str, ...]] = ("ID", "name", "price", "quantity") def normalize_price(price: Decimal) -> Decimal: @@ -48,8 +45,7 @@ def normalize_price(price: Decimal) -> Decimal: ``price`` quantised to :data:`PRICE_PRECISION` fractional digits, with halves rounded up. """ - # TODO: реализуйте функцию (используйте своё решение части 2) - return Decimal(0) + return price.quantize(PRICE_STEP, ROUND_HALF_UP) def normalize_product_name(name: str) -> str: @@ -66,11 +62,18 @@ def normalize_product_name(name: str) -> str: The result is an empty string when ``name`` holds nothing but whitespace. """ - # TODO: реализуйте функцию - return "" + name_words = name.split() + normalized_name = " ".join(name_words).lower() + return normalized_name -# TODO: при необходимости добавьте свои вспомогательные функции + +def get_separator_str(storage_lengths: tuple[int, ...]) -> str: + separator = "|" + for length in storage_lengths: + separator += "-" + "-" * length + "-|" + separator += "\n" + return separator def get_storage_str_representation(storage: list[Product]) -> str: @@ -91,5 +94,37 @@ def get_storage_str_representation(storage: list[Product]) -> str: is empty only the header and separator rows are returned, sized to the header labels. """ - # TODO: реализуйте функцию - return "" + storage_lengths = [] + for i in range(len(TABLE_HEADERS)): + max_value_length = 0 + for elem in storage: + max_value_length = max(len(str(elem[i])), max_value_length) + storage_lengths.append(max(len(str(TABLE_HEADERS[i])), max_value_length)) + + table = "" + + table += "|" + for i in range(len(TABLE_HEADERS)): + table += " " + table += str(TABLE_HEADERS[i]) + " " * ( + storage_lengths[i] - len(str(TABLE_HEADERS[i])) + ) + table += " |" + table += "\n" + + table += get_separator_str(tuple(storage_lengths)) + + for product in storage: + row = "|" + for i in range(len(TABLE_HEADERS)): + row += ( + " " + + str(product[i]) + + " " * (storage_lengths[i] - len(str(product[i]))) + + " |" + ) + table += row + "\n" + + table = table[:-1] + + return table From 57398fb9b54bc2b9ce28f2f7b9065797304de465 Mon Sep 17 00:00:00 2001 From: BICSSA <157736361+BICSSA@users.noreply.github.com> Date: Sun, 1 Nov 2026 16:15:11 +0300 Subject: [PATCH 6/6] =?UTF-8?q?4.=20=D0=A1=D0=BC=D0=BE=D0=BB=D1=8F=D0=BD?= =?UTF-8?q?=D0=B8=D0=BD=D0=BE=D0=B2=20=D0=A1=D1=82=D0=B0=D0=BD=D0=B8=D1=81?= =?UTF-8?q?=D0=BB=D0=B0=D0=B2=20=D0=90=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD?= =?UTF-8?q?=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87.=20613?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/part4/cart.py | 51 ++++++++++++++++++++---- src/part4/crud.py | 80 +++++++++++++++++++++++++++++++------ src/part4/run_admin.py | 89 ++++++++++++++++++++++++++++++++++++------ src/part4/storage.py | 7 ++-- src/part4/utils.py | 62 ++++++++++++++++++++++------- 5 files changed, 237 insertions(+), 52 deletions(-) diff --git a/src/part4/cart.py b/src/part4/cart.py index aed9bb72..694ec0c0 100644 --- a/src/part4/cart.py +++ b/src/part4/cart.py @@ -9,10 +9,8 @@ an explanatory message to stdout and returns ``None``. """ -from .storage import Product - - -# TODO: при необходимости добавьте свои вспомогательные функции +from .crud import read_product +from .storage import QUANTITY_KEY, Product def add_to_cart( @@ -46,8 +44,21 @@ def add_to_cart( ``None`` when the product is unknown or the store cannot cover the request. """ - # TODO: реализуйте функцию - return 0 + product = read_product(storage, product_id) + if product is None: + return None + + in_stock = product[QUANTITY_KEY] + if in_stock < quantity: + print( + f"not enough stock for product {product_id}: " + f"{in_stock} available, {quantity} requested" + ) + return None + + product[QUANTITY_KEY] = in_stock - quantity + cart[product_id] = cart.get(product_id, 0) + quantity + return cart[product_id] def remove_from_cart( @@ -83,5 +94,29 @@ def remove_from_cart( (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 + in_cart = cart.get(product_id) + + if in_cart is None: + print(f"product {product_id} is not in the cart") + return None + + if in_cart < quantity: + print( + f"cart holds only {in_cart} unit(s) of product {product_id}, " + f"cannot remove {quantity}" + ) + return None + + product = read_product(storage, product_id) + if product is None: + return None + + product[QUANTITY_KEY] += quantity + + left = in_cart - quantity + if left == 0: + del cart[product_id] + return 0 + + cart[product_id] = left + return left diff --git a/src/part4/crud.py b/src/part4/crud.py index 471eff00..91484d06 100644 --- a/src/part4/crud.py +++ b/src/part4/crud.py @@ -23,16 +23,16 @@ 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: @@ -41,8 +41,7 @@ def generate_product_id() -> str: Returns: A freshly generated UUID, stringified. """ - # TODO: реализуйте функцию - return "" + return str(uuid.uuid4()) def create_product( @@ -73,8 +72,27 @@ def create_product( and ``product_names`` are left unchanged and an explanatory message is printed. """ - # TODO: реализуйте функцию - return "" + name = normalize_product_name(fields[NAME_KEY]) + price = fields[PRICE_KEY] + quantity = fields[QUANTITY_KEY] + + if not name: + print("product name must not be blank") + return None + + if name in product_names: + print(f"product name '{name}' is already taken") + return None + + product_id = generate_product_id() + storage[product_id] = { + NAME_KEY: name, + PRICE_KEY: normalize_price(price), + QUANTITY_KEY: quantity, + } + product_names.add(name) + + return product_id def read_product(storage: dict[str, Product], product_id: str) -> Product | None: @@ -88,8 +106,13 @@ def read_product(storage: dict[str, Product], product_id: str) -> Product | None The matching product record, or ``None`` when no product carries that identifier (a message is printed in that case). """ - # TODO: реализуйте функцию - return {} + product = storage.get(product_id) + + if product is None: + print(f"no product with id {product_id}") + return None + + return product def update_product( @@ -129,8 +152,34 @@ def update_product( and an explanatory message is printed. Renaming a product to its own current name is allowed. """ - # TODO: реализуйте функцию - return {} + existing_product = read_product(storage, product_id) + if existing_product is None: + return None + + if NAME_KEY in fields: + name = normalize_product_name(fields[NAME_KEY]) + + if not name: + print("product name must not be blank") + return None + + if name != existing_product[NAME_KEY] and name in product_names: + print(f"product name '{name}' is already taken") + return None + + fields[NAME_KEY] = name + + if PRICE_KEY in fields: + fields[PRICE_KEY] = normalize_price(fields[PRICE_KEY]) + + old_name = existing_product[NAME_KEY] + existing_product.update(fields) + + if existing_product[NAME_KEY] != old_name: + product_names.discard(old_name) + product_names.add(existing_product[NAME_KEY]) + + return existing_product def delete_product( @@ -153,5 +202,10 @@ def delete_product( product carried that identifier (``storage`` and ``product_names`` are left unchanged and a message is printed). """ - # TODO: реализуйте функцию - return "" + product = read_product(storage, product_id) + if product is None: + return None + + product_names.discard(product[NAME_KEY]) + del storage[product_id] + return product_id diff --git a/src/part4/run_admin.py b/src/part4/run_admin.py index 2247b29b..fb6cbe73 100644 --- a/src/part4/run_admin.py +++ b/src/part4/run_admin.py @@ -28,22 +28,32 @@ is left untouched and the loop keeps running; only ``exit`` stops it. """ -from decimal import Decimal, InvalidOperation # noqa: F401 -from typing import Final +from decimal import Decimal, InvalidOperation +from typing import Any, 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 +from .storage import NAME_KEY, PRICE_KEY, QUANTITY_KEY, Product +from .utils import get_storage_str_representation -# TODO: задайте приглашение и текст справки (используйте своё решение части 3) -PROMPT: Final[str] = "" -HELP_TEXT: Final[str] = "" +PROMPT: Final[str] = "admin> " +HELP_TEXT: Final[str] = """Available commands: + help show this message + exit leave the console + show print the whole store as a table + create add a product, print its new id + read print the product with that id + update overwrite that product's fields + delete remove the product with that id + +For create and update the price and quantity are the last two words of the +line; everything before them is the product name, so it may contain spaces +(for example "Gibson SG Junior") and needs no quoting.""" def show_help() -> None: @@ -53,7 +63,7 @@ def show_help() -> None: 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: @@ -64,7 +74,31 @@ def print_result(result: object) -> None: operation already reported its own failure, so nothing is printed in that case. """ - # TODO: реализуйте функцию (используйте своё решение части 3) + if result is not None: + print(result) + + +def build_fields(name: list[str], price: str, quantity: str) -> dict[str, Any]: + """Build the ``fields`` dictionary for ``create`` and ``update``. + + Args: + name: The words of the product name, joined with single spaces. + price: The raw price argument. + quantity: The raw quantity argument. + + Returns: + A dictionary with the ``name``, ``price`` and ``quantity`` keys. + + Raises: + ValueError: If ``quantity`` does not parse as a base-10 integer. + decimal.InvalidOperation: If ``price`` does not parse as a decimal + number. + """ + return { + NAME_KEY: " ".join(name), + PRICE_KEY: Decimal(price), + QUANTITY_KEY: int(quantity), + } def run_command( @@ -91,8 +125,39 @@ def run_command( decimal.InvalidOperation: If the price argument of ``create`` or ``update`` does not parse as a decimal number. """ - # TODO: реализуйте функцию - return False + match line.split(): + 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 ["create", *name, price, quantity] if name: + fields = build_fields(name, price, quantity) + print_result(create_product(storage, product_names, fields)) + return True + + case ["update", product_id, *name, price, quantity] if name: + fields = build_fields(name, price, quantity) + print_result(update_product(storage, product_names, product_id, fields)) + return True + + case _: + print(f"'{line}' is not a command") + return True def main() -> None: diff --git a/src/part4/storage.py b/src/part4/storage.py index 9acedf07..f0034782 100644 --- a/src/part4/storage.py +++ b/src/part4/storage.py @@ -39,7 +39,6 @@ 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..372fb6a7 100644 --- a/src/part4/utils.py +++ b/src/part4/utils.py @@ -18,10 +18,10 @@ 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, @@ -31,16 +31,16 @@ # 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") + +# Number of spaces between a cell's text and the border on each side. +CELL_PADDING: Final[int] = 1 def normalize_price(price: Decimal) -> Decimal: @@ -53,8 +53,7 @@ def normalize_price(price: Decimal) -> Decimal: ``price`` quantised to :data:`PRICE_PRECISION` fractional digits, with halves rounded up. """ - # TODO: реализуйте функцию (используйте своё решение части 3) - return Decimal(0) + return price.quantize(PRICE_STEP, ROUND_HALF_UP) def normalize_product_name(name: str) -> str: @@ -71,11 +70,24 @@ def normalize_product_name(name: str) -> str: The result is an empty string when ``name`` holds nothing but whitespace. """ - # TODO: реализуйте функцию (используйте своё решение части 3) - return "" + return " ".join(name.split()).lower() + + +def format_row(cells: list[str], widths: list[int]) -> str: + """Render one table row, padding each cell to its column width. + Args: + cells: The text of each cell, left to right. + widths: The width of each column, left to right. -# TODO: при необходимости добавьте свои вспомогательные функции + Returns: + The row as ``| a | b | c | d |`` with every cell padded on the + right to its column width. + """ + padded_cells = [cell.ljust(width) for cell, width in zip(cells, widths)] + padding = " " * CELL_PADDING + joiner = f"{padding}|{padding}" + return f"|{padding}{joiner.join(padded_cells)}{padding}|" def get_storage_str_representation(storage: dict[str, Product]) -> str: @@ -96,5 +108,25 @@ def get_storage_str_representation(storage: dict[str, Product]) -> str: ``storage`` is empty only the header and separator rows are returned, sized to the header labels. """ - # TODO: реализуйте функцию (используйте своё решение части 3) - return "" + rows = [ + [ + product_id, + record[NAME_KEY], + str(record[PRICE_KEY]), + str(record[QUANTITY_KEY]), + ] + for product_id, record in storage.items() + ] + + widths = [ + max([len(header)] + [len(row[i]) for row in rows]) + for i, header in enumerate(TABLE_HEADERS) + ] + + dashes = ["-" * (width + 2 * CELL_PADDING) for width in widths] + separator = "|" + "|".join(dashes) + "|" + + lines = [format_row(list(TABLE_HEADERS), widths), separator] + lines.extend(format_row(row, widths) for row in rows) + + return "\n".join(lines)