2. Безымянный Сергей Андреевич. 613

src/part2/cart.py

@@ -1,30 +1,30 @@
-"""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,
     Product,
 )
 
 
-type CartLine = tuple[int, int]
+CartLine = tuple[int, int]
+
+LINE_PRODUCT_ID_INDEX: Final[int] = 0
+LINE_QUANTITY_INDEX: Final[int] = 1
+
 
-# TODO: задайте позиции полей внутри кортежа CartLine
-LINE_PRODUCT_ID_INDEX: Final = 0
-LINE_QUANTITY_INDEX: Final = 0
+def find_cart_line(
+    cart: list[CartLine],
+    product_id: int,
+) -> CartLine | None:
+    for line in cart:
+        if line[LINE_PRODUCT_ID_INDEX] == product_id:
+            return line
+
+    print(f"Product {product_id} is not in the cart")
+    return None
 
 
 def add_to_cart(
@@ -33,28 +33,45 @@ 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)
+    product = read_product(storage, product_id)
+
+    if product is None:
+        return None
+
+    storage_quantity = product[QUANTITY_INDEX]
+
+    if storage_quantity < quantity:
+        print(
+            f"Not enough stock for product {product_id}: "
+            f"{storage_quantity} available, "
+            f"{quantity} requested."
+        )
+        return None
+
+    new_fields = (
+        product[NAME_INDEX],
+        product[PRICE_INDEX],
+        storage_quantity - quantity,
+    )
+
+    update_product(
+        storage,
+        product_id,
+        new_fields,
+    )
+
+    for index, line in enumerate(cart):
+        if line[LINE_PRODUCT_ID_INDEX] == product_id:
+            new_line = (
+                product_id,
+                line[LINE_QUANTITY_INDEX] + quantity,
+            )
+            cart[index] = new_line
+            return new_line
+
+    new_line = (product_id, quantity)
+    cart.append(new_line)
+    return new_line
 
 
 def remove_from_cart(
@@ -63,27 +80,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)
+    cart_line = find_cart_line(cart, product_id)
+
+    if cart_line is None:
+        return None
+
+    if cart_line[LINE_QUANTITY_INDEX] < quantity:
+        print(
+            f"Cart holds only {cart_line[LINE_QUANTITY_INDEX]} "
+            f"unit(s) of product {product_id}, "
+            f"cannot remove {quantity}."
+        )
+        return None
+
+    product = read_product(storage, product_id)
+
+    if product is None:
+        return None
+
+    new_quantity = product[QUANTITY_INDEX] + quantity
+
+    new_fields = (
+        product[NAME_INDEX],
+        product[PRICE_INDEX],
+        new_quantity,
+    )
+
+    update_product(
+        storage,
+        product_id,
+        new_fields,
+    )
+
+    new_line: CartLine = (
+        product_id,
+        cart_line[LINE_QUANTITY_INDEX] - quantity,
+    )
+
+    if new_line[LINE_QUANTITY_INDEX] == 0:
+        cart.remove(cart_line)
+        return new_line
+
+    for index, line in enumerate(cart):
+        if line == cart_line:
+            cart[index] = new_line
+            return new_line
+
+    return None

src/part2/crud.py

@@ -1,120 +1,91 @@
-"""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``.
+def create_product(
+    storage: list[Product],
+    fields: tuple[str, Decimal, int],
+) -> int | None:
+    product_name, product_price, product_quantity = fields
 
-    Args:
-        storage: The product store to inspect.
+    for product in storage:
+        if product_name == product[NAME_INDEX]:
+            print(f"Product name {product_name} is already taken.")
+            return None
 
-    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
+    product_id = generate_product_id(storage)
 
+    storage.append(
+        (
+            product_id,
+            product_name,
+            normalize_price(product_price),
+            product_quantity,
+        )
+    )
+
+    return product_id
 
-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.
+def generate_product_id(storage: list[Product]) -> int:
+    if not storage:
+        return PRODUCT_ID_MIN
 
-    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
+    max_id = max(product[PRODUCT_ID_INDEX] for product in storage)
 
+    return max_id + 1
 
-def read_product(storage: list[Product], product_id: int) -> Product | None:
-    """Return the product stored under ``product_id``.
 
-    Args:
-        storage: The product store to search.
-        product_id: The identifier to look up.
+def read_product(
+    storage: list[Product],
+    product_id: int,
+) -> Product | None:
+    for product in storage:
+        if product[PRODUCT_ID_INDEX] == product_id:
+            return product
 
-    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)
+    print(f"No product with id {product_id}")
+    return None
 
 
 def update_product(
     storage: list[Product],
     product_id: int,
     fields: tuple[str, Decimal, int],
 ) -> Product | None:
-    """Overwrite the fields of the product stored under ``product_id``.
-
-    The identifier itself is preserved; only ``name``, ``price`` and
-    ``quantity`` are replaced.
-
-    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)
-
-
-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 index, product in enumerate(storage):
+        if product[PRODUCT_ID_INDEX] == product_id:
+            new_name, new_price, new_quantity = fields
+
+            new_product: Product = (
+                product_id,
+                new_name,
+                normalize_price(new_price),
+                new_quantity,
+            )
+
+            storage[index] = new_product
+            return new_product
+
+    print(f"No product with id {product_id}")
+    return None
+
+
+def delete_product(
+    storage: list[Product],
+    product_id: int,
+) -> int | None:
+    for index, product in enumerate(storage):
+        if product[PRODUCT_ID_INDEX] == product_id:
+            storage.pop(index)
+            return product_id
+
+    print(f"No product with id {product_id}.")
+    return None