person_test

from dataclasses import dataclass, asdict
from uuid import (
    UUID,
    uuid4,
)



@dataclass
class Person:
    """
    Информация о пользователе.

    Attrs:
        login: логин пользователя.
        password: пароль пользователя.
        username: имя пользователя.
        metadata: дополнительные сведения о пользователе.
    """

    login: str = ""
    password: str = ""
    username: str = ""
    metadata: str = ""



class PersonDB:
    _database: dict[UUID, Person]
    _login_registry: set[str]
    _min_password_len = 10

    def __init__(self) -> None:
        """Инициализирует базу данных."""
        # ваш код
        self._database = {}
        self._login_registry = set()

    def _check_password(self, password):
        """
        Пароль считается надежным, если
пароль содержит хотя бы одну букву английского алфавита в верхнем регистре;
пароль содержит хотя бы одну букву английского алфавита в нижнем регистре;
пароль содержит хотя бы одну цифру от 0 до 9;
пароль состоит не менее чем из 10 символов;
пароль не содержит никаких символов, кроме разрешенных.
        """
        alph_lower = 'abcdefghijklmnopqrstuvwxyz'
        alph_upper = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
        num = '0123456789'
        if len(password) < self._min_password_len:
            return False
        contains_alph_lower = False
        contains_alph_upper = False
        contains_num = False
        for l in password:
            if l in alph_lower:
                contains_alph_lower = True
            elif l in alph_upper:
                contains_alph_upper = True
            elif l in num:
                contains_num = True
            else:
                return False
        return contains_alph_lower and contains_alph_upper and contains_num

    def _check_login(self, login):
        """
         Логин должен быть уникальным и содержать только английские буквы в верхнем и нижнем регистре, а также цифры от 0 до 9. Логин не может быть пустой строкой.
        """
        #print("login is", login)
        return login != '' and login.isalnum()

    def _check_login_and_password(self, login, password):
        #print("checking login and password")
        #print("login is", login)
        #print("password is", password)
        login_is_ok = self._check_login(login)
        if not login_is_ok:
            raise ValueError("incorrect login")
        if login in self._login_registry:
            raise ValueError("such login already exists")
        password_is_ok = self._check_password(password)
        if not password_is_ok:
            raise ValueError("incorrect password")

    def create_person(self, person: Person) -> UUID:
        """
        Создает новую запись о пользователе в базе данных.

        Args:
            person: данные о пользователе, которые будут помещены в БД.

        Returns:
            UUID - идентификатор, который будет связан с созданной записью.

        Raises:
            ValueError, если логин или пароль не удовлетворяют требованиям.
        """
        #print("creating person")
        #print(person)
        self._check_login_and_password(person.login, person.password)
        id = uuid4()
        if id in self._database:
            raise Exception("such id already exists")
        self._login_registry.add(person.login)
        self._database[id] = person
        #print("creating")
        #print("id is", id)
        return id
        # ваш код

    def read_person_info(self, person_id: UUID) -> Person:
        """
        Читает актуальные данные пользователя из базы данных.

        Args:
            person_id: идентификатор пользователя в формате UUID.

        Returns:
            Данные о пользователе, упакованные в структуру Person.

        Raises:
            KeyError, если в базе данных нет пользователя с person_id.
        """
        if person_id not in self._database:
            raise KeyError("no person with such id")
        return self._database[person_id]

    def update_person_info(self, person_id: UUID, person_info_new: Person) -> None:
        """
        Обновляет данные о пользователе.

        Args:
            person_id: идентификатор пользователя в формате UUID.
            person_info_new: модель со значениями на обновление. Будут обновлены
                только те поля, чье значение отличается от пустой строки '',
                остальные поля будут оставлены без изменений.

        Raises:
            ValueError, если при обновлении логина или пароля логин или пароль
                не прошли этап валидации.
            KeyError, если в базе данных нет пользователя с person_id.
        """
        #print("updating")
        #print(self._database[person_id])
        if person_id not in self._database:
            raise KeyError("no person with such id")
        self._check_login_and_password(person_info_new.login, person_info_new.password)
        """
        параметр откуда взять?
                for par in asdict(person_info_new):
            if par != '':
                self._database[person_id] = person_info_new.
        """
        """
        login: str = ""
    password: str = ""
    username: str = ""
    metadata: str = ""
        """
        print("in database before updating")
        print(self._database[person_id])
        print()
        print("person_info_new")
        print(person_info_new)
        print()
        old_login = self._database[person_id].login
        new_person = Person()
        dict_helper = asdict(self._database[person_id])
        #сли копироавть каждое поле отдельно - то там будет ссылка или значение копироваться?
        #как надо былобез dict_helper?
        new_person.login = dict_helper['login']
        new_person.password = dict_helper['password']
        new_person.username = dict_helper['username']
        new_person.metadata = dict_helper['metadata']
        #asdict(self._database[person_id])
        print("new_person before updating")
        print(new_person)
        print()
        if person_info_new.login != '':
            self._login_registry.remove(old_login)
            new_person.login = person_info_new.login
            self._login_registry.add(new_person.login)
        if person_info_new.password != '':
            new_person.password = person_info_new.password
        if person_info_new.username != '':
            new_person.username = person_info_new.username
        if person_info_new.metadata != '':
            new_person.metadata = person_info_new.metadata
        print("updated")
        print(new_person)
        print()
        self._database[person_id] = new_person


    def delete_person(self, person_id: UUID) -> None:
        """
        Удаляет запись о пользователе.

        Args:
            person_id: идентификатор пользователя в формате UUID.

        Raises:
            KeyError, если в базе данных нет пользователя с person_id.
        """
        if person_id not in self._database:
            raise KeyError("no person with such id")
        self._database.pop(person_id)


"""
p = Person('ninja', 'aA0123456789', 'Eminem', 'This ninja is Eminem')
db = PersonDB()
check_id = db.create_person(p)
p2 = Person('ninja2', 'aA6123456789', 'Taylor Swift', 'This ninja is Taylor Swift')
check_id2 = db.create_person(p2)
#print("check id is", check_id)
#print(db._database)
print(db.read_person_info(check_id))
print(db.read_person_info(check_id2))
#print(asdict(db))
print(db._login_registry)
print(db._database)
"""
person1 = Person(
    password="Aa1Bb2Cc3Dd4",
    login="login1",
    username="user#1",
)

database = PersonDB()
person1_id = database.create_person(person1)

assert len(database._database) == 1
assert len(database._login_registry) == 1
assert person1_id in database._database
assert person1.login in database._login_registry
assert database._database[person1_id] == person1

persons_wrong = {
    "no-login": Person(
        password="Aa1Bb2Cc3Dd4",
        login="",
        username="user#2",
    ),
    "existed-login": Person(
        password="Aa1Bb2Cc3Dd4",
        login="login1",
        username="user#2",
    ),
    "too-short-password": Person(
        password="12345",
        login="login2",
        username="user#2",
    ),
    "no-lower": Person(
        password="A1B2C3D4E5F",
        login="login2",
        username="user#2",
    ),
    "no-upper": Person(
        password="a1b2c3d4e5f",
        login="login2",
        username="user#2",
    ),
    "no-digits": Person(
        password="aAbBcCdDeEf",
        login="login2",
        username="user#2",
    ),
}

for test_name, wrong_person in persons_wrong.items():
    try:
        database.create_person(wrong_person)
        assert False, test_name

    except ValueError:
        assert True
        assert len(database._database) == 1
        assert len(database._login_registry) == 1


person = database.read_person_info(person1_id)
assert person1 == person
assert len(database._database) == 1
assert len(database._login_registry) == 1

try:
    fake_id = uuid4()
    person = database.read_person_info(fake_id)
    assert False

except KeyError:
    assert True
    assert len(database._database) == 1
    assert len(database._login_registry) == 1

person2 = Person(
    password="AaBbcC1234Dd",
    login="login2",
    username="user#2"
)
person2_id = database.create_person(person2)
assert len(database._database) == 2
assert len(database._login_registry) == 2
assert person2_id in database._database
assert person2.login in database._login_registry
assert database._database[person2_id] == person2

person2_updated = Person(
    password="abcDEF123456",
    login="LOGIN2",
    username="user#2",
)
person2_update = Person(
    password="abcDEF123456",
    login="LOGIN2",
    username="",
)

database.update_person_info(person2_id, person2_update)
#print(person2_updated)
#print(person2)
#print(person2_id)
#print(database._database[person2_id])
#print(database._login_registry)

#print(person2_updated)
#print(person2_updated)
#print(database._login_registry)
#print(person2_updated.login)
#print(person2.login)
print(person2_updated)
print(database._database[person2_id])
assert len(database._database) == 2
assert len(database._login_registry) == 2
assert person2_id in database._database
assert person2.login not in database._login_registry
assert person2_updated.login in database._login_registry
assert database._database[person2_id] == person2_updated