Нейросети для кода и разработки в одном кабинете

from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.responses import JSONResponse

app = FastAPI()

MAX_SIZE_BYTES = 5 * 1024 * 1024  # 5 MB
CHUNK_SIZE = 64 * 1024  # 64 KB

PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
JPEG_SOI = b"\xff\xd8"  # Start Of Image


def sniff_image_type(initial_bytes: bytes) -> str | None:
    # Check PNG signature (first 8 bytes)
    if initial_bytes.startswith(PNG_SIGNATURE):
        return "image/png"
    # Check JPEG signature (starts with 0xFFD8)
    if initial_bytes.startswith(JPEG_SOI):
        return "image/jpeg"
    return None


@app.post("/upload")
async def upload_image(file: UploadFile = File(...)):
    """
    Accepts PNG and JPEG up to 5 MB.
    Returns 400 for any other file type or if size exceeds 5 MB.
    """
    total_read = 0
    first_chunk = b""

    try:
        # Read the first chunk to determine type and start counting size
        first_chunk = await file.read(CHUNK_SIZE)
        total_read += len(first_chunk)

        if not first_chunk:
            raise HTTPException(status_code=400, detail="Файл пустой или не был загружен.")

        detected_type = sniff_image_type(first_chunk)
        if detected_type not in {"image/png", "image/jpeg"}:
            raise HTTPException(status_code=400, detail="Разрешены только PNG и JPEG.")

        if total_read > MAX_SIZE_BYTES:
            raise HTTPException(status_code=400, detail="Файл превышает максимально допустимый размер 5 МБ.")

        # Continue reading the rest to enforce size limit
        while True:
            chunk = await file.read(CHUNK_SIZE)
            if not chunk:
                break
            total_read += len(chunk)
            if total_read > MAX_SIZE_BYTES:
                raise HTTPException(status_code=400, detail="Файл превышает максимально допустимый размер 5 МБ.")

        # If needed, here you could store the file; currently just validates and acknowledges upload.
        return JSONResponse(
            {
                "filename": file.filename,
                "content_type": detected_type,
                "size_bytes": total_read,
                "detail": "Загрузка прошла успешно.",
            }
        )
    finally:
        # Ensure the temporary file is closed
        await file.close()


# For local testing: uvicorn this_module:app --reload
if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="127.0.0.1", port=8000)

# test_split_price.py
import pytest

from split_price import split_price  # замените на реальный путь импорта


# ---------------------------------------------------------------------------
# 1. Базовое поведение
# ---------------------------------------------------------------------------

@pytest.mark.parametrize(
    "total, parts, expected",
    [
        (10, 1, [10]),
        (10, 2, [5, 5]),
        (10, 3, [4, 3, 3]),
        (10, 4, [3, 3, 2, 2]),
        (100, 3, [34, 33, 33]),
        (7, 7, [1, 1, 1, 1, 1, 1, 1]),
        (1, 3, [1, 0, 0]),
        (2, 3, [1, 1, 0]),
    ],
)
def test_exact_distribution(total, parts, expected):
    assert split_price(total, parts) == expected


# ---------------------------------------------------------------------------
# 2. Невалидный ввод: parts <= 0
# ---------------------------------------------------------------------------

@pytest.mark.parametrize("parts", [0, -1, -2, -100])
def test_non_positive_parts_raises(parts):
    with pytest.raises(ValueError, match="parts must be positive"):
        split_price(100, parts)


def test_zero_parts_raises_even_for_zero_total():
    """«Пустой ввод»: нечего делить и не на что — всё равно ValueError."""
    with pytest.raises(ValueError, match="parts must be positive"):
        split_price(0, 0)


def test_error_raised_before_any_computation():
    """Проверка порядка: исключение, а не деление на ноль (ZeroDivisionError)."""
    with pytest.raises(ValueError):
        split_price(10, 0)


# ---------------------------------------------------------------------------
# 3. Нулевой / пустой total
# ---------------------------------------------------------------------------

@pytest.mark.parametrize("parts", [1, 2, 5, 100])
def test_zero_total_gives_all_zeros(parts):
    result = split_price(0, parts)
    assert result == [0] * parts
    assert sum(result) == 0


def test_total_less_than_parts():
    """Часть получателей получает 0 — список не «схлопывается»."""
    result = split_price(3, 10)
    assert result == [1, 1, 1, 0, 0, 0, 0, 0, 0, 0]
    assert len(result) == 10


# ---------------------------------------------------------------------------
# 4. Граничные случаи по размеру
# ---------------------------------------------------------------------------

def test_single_part_returns_whole_total():
    assert split_price(999_999, 1) == [999_999]


def test_large_parts_count():
    parts = 10_000
    result = split_price(12_345, parts)
    assert len(result) == parts
    assert sum(result) == 12_345
    assert set(result) == {1, 2}


def test_large_total():
    total, parts = 10**18 + 7, 3
    result = split_price(total, parts)
    assert sum(result) == total
    assert max(result) - min(result) <= 1


# ---------------------------------------------------------------------------
# 5. Отрицательный total (документируем текущее поведение divmod)
# ---------------------------------------------------------------------------

@pytest.mark.parametrize(
    "total, parts, expected",
    [
        (-10, 2, [-5, -5]),
        (-10, 3, [-3, -3, -4]),   # divmod(-10, 3) == (-4, 2)
        (-1, 3, [0, 0, -1]),
    ],
)
def test_negative_total_behaviour(total, parts, expected):
    assert split_price(total, parts) == expected
    assert sum(expected) == total


# ---------------------------------------------------------------------------
# 6. Инварианты (свойства функции)
# ---------------------------------------------------------------------------

CASES = [(t, p) for t in (0, 1, 2, 7, 10, 99, 1000, -7) for p in (1, 2, 3, 5, 7, 11)]


@pytest.mark.parametrize("total, parts", CASES)
def test_sum_is_preserved(total, parts):
    assert sum(split_price(total, parts)) == total


@pytest.mark.parametrize("total, parts", CASES)
def test_length_equals_parts(total, parts):
    assert len(split_price(total, parts)) == parts


@pytest.mark.parametrize("total, parts", CASES)
def test_difference_at_most_one(total, parts):
    result = split_price(total, parts)
    assert max(result) - min(result) <= 1


@pytest.mark.parametrize("total, parts", CASES)
def test_result_is_non_increasing(total, parts):
    """Остаток раздаётся первым элементам, поэтому список не возрастает."""
    result = split_price(total, parts)
    assert result == sorted(result, reverse=True)


@pytest.mark.parametrize("total, parts", CASES)
def test_all_items_are_ints(total, parts):
    result = split_price(total, parts)
    assert isinstance(result, list)
    assert all(isinstance(x, int) and not isinstance(x, bool) for x in result)


@pytest.mark.parametrize("total, parts", CASES)
def test_deterministic(total, parts):
    assert split_price(total, parts) == split_price(total, parts)


def test_result_is_fresh_list_each_call():
    """Мутация результата не влияет на последующие вызовы."""
    first = split_price(10, 3)
    first[0] = 999
    assert split_price(10, 3) == [4, 3, 3]


# ---------------------------------------------------------------------------
# 7. Типы аргументов
# ---------------------------------------------------------------------------

def test_bool_parts_is_treated_as_one_part():
    """bool — подкласс int; True == 1, поведение не должно падать."""
    assert split_price(10, True) == [10]


def test_false_parts_raises():
    with pytest.raises(ValueError, match="parts must be positive"):
        split_price(10, False)


@pytest.mark.parametrize("bad", [None, "3", 3.5, [3], {}])
def test_non_int_parts_raises_type_error(bad):
    with pytest.raises((TypeError, ValueError)):
        split_price(10, bad)


@pytest.mark.parametrize("bad", [None, "10", [10], {}])
def test_non_int_total_raises_type_error(bad):
    with pytest.raises(TypeError):
        split_price(bad, 3)

#!/usr/bin/env python3
import glob

def main():
    for path in sorted(glob.glob("logs/*.log")):
        try:
            with open(path, "r", encoding="utf-8", errors="replace") as f:
                count = sum(1 for line in f if "ERROR" in line)
        except OSError:
            # If a file can't be read, skip it (similar to grep erroring out and producing no count)
            continue

        if count > 0:
            print(f"{path}: {count}")

if __name__ == "__main__":
    main()

Вот регулярное выражение и скрипт на Python с проверкой различных форматов:


import re

# Регулярное выражение для валидации российских номеров:
# - Поддерживает префикс +7 или 8
# - Код города/оператора может быть в скобках: (900) или без: 900
# - Разделители: пробелы, дефисы или их отсутствие
pattern = re.compile(
    r"^(?:\+7|8)[\s-]?(?:\((\d{3})\)|(\d{3}))[\s-]?(\d{3})[\s-]?(\d{2})[\s-]?(\d{2})$"
)

# Тестовые номера
test_phones = [
    # Корректные форматы
    "+7 900 123-45-67",
    "8 (900) 123-45-67",
    "89001234567",
    "+7(900)1234567",
    "+7 900 123 45 67",
    "8-900-123-45-67",
    "+79001234567",
    # Некорректные форматы
    "9001234567",  # нет кода страны (+7 или 8)
    "+7 (900 123-45-67",  # незакрытая скобка
    "+7 900 123-45-6",  # не хватает цифры
    "+7 900 123-45-678",  # лишняя цифра
    "+1 900 123-45-67",  # код другой страны
]


def normalize_phone(phone: str) -> str | None:
    """Проверяет номер и приводит его к единому формату +7 (XXX) XXX-XX-XX."""
    match = pattern.match(phone.strip())
    if not match:
        return None

    # Извлекаем группы цифр
    code = match.group(1) or match.group(2)
    part1, part2, part3 = match.group(3), match.group(4