passphera-core 0.10.0__tar.gz → 0.11.1__tar.gz

{passphera_core-0.10.0 → passphera_core-0.11.1}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.2
 Name: passphera-core
-Version: 0.10.0
+Version: 0.11.1
 Summary: The core system of passphera project
 Home-page: https://github.com/passphera/core
 Author: Fathi Abdelmalek
 Author-email: abdelmalek.fathi.2001@gmail.com
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python

passphera_core-0.11.1/passphera_core/application/generator.py

@@ -0,0 +1,57 @@
+from datetime import datetime, timezone
+from uuid import UUID
+
+from passphera_core.entities import Generator
+from passphera_core.interfaces import GeneratorRepository
+
+
+class GetGeneratorUseCase:
+    def __init__(self, generator_repository: GeneratorRepository):
+        self.generator_repository: GeneratorRepository = generator_repository
+
+    def execute(self, generator_id: UUID) -> Generator:
+        return self.generator_repository.get(generator_id)
+    
+    
+class GetGeneratorPropertyUseCase:
+    def __init__(self, generator_repository: GeneratorRepository):
+        self.generator_repository: GeneratorRepository = generator_repository
+
+    def execute(self, generator_id: UUID, field: str) -> str:
+        generator_entity: Generator = self.generator_repository.get(generator_id)
+        return getattr(generator_entity, field)
+
+
+class UpdateGeneratorPropertyUseCase:
+    def __init__(self, generator_repository: GeneratorRepository):
+        self.generator_repository: GeneratorRepository = generator_repository
+
+    def execute(self, generator_id: UUID, field: str, value: str) -> None:
+        generator_entity: Generator = self.generator_repository.get(generator_id)
+        setattr(generator_entity, field, value)
+        if field == 'algorithm':
+            generator_entity.get_algorithm()
+        generator_entity.updated_at = datetime.now(timezone.utc)
+        self.generator_repository.update(generator_entity)
+
+
+class AddCharacterReplacementUseCase:
+    def __init__(self, generator_repository: GeneratorRepository):
+        self.generator_repository: GeneratorRepository = generator_repository
+
+    def execute(self, generator_id: UUID, character: str, replacement: str) -> None:
+        generator_entity: Generator = self.generator_repository.get(generator_id)
+        generator_entity.replace_character(character, replacement)
+        generator_entity.updated_at = datetime.now(timezone.utc)
+        self.generator_repository.update(generator_entity)
+
+
+class ResetCharacterReplacementUseCase:
+    def __init__(self, generator_repository: GeneratorRepository,):
+        self.generator_repository: GeneratorRepository = generator_repository
+
+    def execute(self, generator_id: UUID, character: str) -> None:
+        generator_entity: Generator = self.generator_repository.get(generator_id)
+        generator_entity.reset_character(character)
+        generator_entity.updated_at = datetime.now(timezone.utc)
+        self.generator_repository.update(generator_entity)

passphera_core-0.11.1/passphera_core/application/password.py

@@ -0,0 +1,86 @@
+from uuid import UUID
+
+from passphera_core.entities import Password, Generator
+from passphera_core.exceptions import DuplicatePasswordException, PasswordNotFoundException
+from passphera_core.interfaces import PasswordRepository, GeneratorRepository
+
+
+class GeneratePasswordUseCase:
+    def __init__(
+            self,
+            password_repository: PasswordRepository,
+            generator_repository: GeneratorRepository,
+    ):
+        self.password_repository: PasswordRepository = password_repository
+        self.generator_repository: GeneratorRepository = generator_repository
+
+    def execute(self, generator_id: UUID, context: str, text: str) -> Password:
+        password_entity: Password = self.password_repository.get_by_context(context)
+        if password_entity:
+            raise DuplicatePasswordException(password_entity)
+        generator_entity: Generator = self.generator_repository.get(generator_id)
+        password: str = generator_entity.generate_password(text)
+        password_entity: Password = Password(context=context, text=text, password=password)
+        password_entity.encrypt()
+        self.password_repository.save(password_entity)
+        return password_entity
+
+
+class GetPasswordByContextUseCase:
+    def __init__(self, password_repository: PasswordRepository):
+        self.password_repository: PasswordRepository = password_repository
+
+    def execute(self, context: str) -> Password:
+        password_entity: Password = self.password_repository.get_by_context(context)
+        if not password_entity:
+            raise PasswordNotFoundException()
+        return password_entity
+
+
+class UpdatePasswordUseCase:
+    def __init__(
+            self,
+            password_repository: PasswordRepository,
+            generator_repository: GeneratorRepository,
+    ):
+        self.password_repository: PasswordRepository = password_repository
+        self.generator_repository: GeneratorRepository = generator_repository
+
+    def execute(self, generator_id: UUID, context: str, text: str) -> Password:
+        password_entity: Password = self.password_repository.get_by_context(context)
+        if not password_entity:
+            raise PasswordNotFoundException()
+        generator_entity: Generator = self.generator_repository.get(generator_id)
+        password: str = generator_entity.generate_password(text)
+        password_entity.text = text
+        password_entity.password = password
+        password_entity.encrypt()
+        self.password_repository.update(password_entity)
+        return password_entity
+
+
+class DeletePasswordUseCase:
+    def __init__(self, password_repository: PasswordRepository):
+        self.password_repository: PasswordRepository = password_repository
+
+    def execute(self, context: str) -> None:
+        password_entity: Password = self.password_repository.get_by_context(context)
+        if not password_entity:
+            raise PasswordNotFoundException()
+        self.password_repository.delete(password_entity)
+
+
+class GetAllPasswordsUseCase:
+    def __init__(self, password_repository: PasswordRepository):
+        self.password_repository: PasswordRepository = password_repository
+
+    def execute(self) -> list[Password]:
+        return self.password_repository.list()
+
+
+class DeleteAllPasswordsUseCase:
+    def __init__(self, password_repository: PasswordRepository):
+        self.password_repository: PasswordRepository = password_repository
+
+    def execute(self) -> None:
+        self.password_repository.flush()

{passphera_core-0.10.0 → passphera_core-0.11.1}/passphera_core/entities.py

@@ -5,22 +5,19 @@ from uuid import UUID, uuid4
 from cryptography.fernet import Fernet
 
 from cipherspy.cipher import *
-from cipherspy.cipher.base_cipher import BaseCipherAlgorithm
+from cipherspy.exceptions import InvalidAlgorithmException
 from cipherspy.utilities import generate_salt, derive_key
 
-from passphera_core import exceptions
-
 
 @dataclass
 class Password:
     id: UUID = field(default_factory=uuid4)
-    user_id: UUID = field(default_factory=uuid4)
-    created_at: datetime = field(default=datetime.now(timezone.utc))
-    updated_at: datetime = field(default=datetime.now(timezone.utc))
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
     context: str = field(default_factory=str)
     text: str = field(default_factory=str)
     password: str = field(default_factory=str)
-    salt: bytes = field(default_factory=bytes)
+    salt: bytes = field(default_factory=lambda: bytes)
 
     def encrypt(self) -> None:
         self.salt = generate_salt()
@@ -33,9 +30,10 @@ class Password:
 
 
 @dataclass
-class GeneratorConfig:
+class Generator:
     id: UUID = field(default_factory=uuid4)
-    generator_id: UUID = field(default_factory=uuid4)
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
     shift: int = field(default=3)
     multiplier: int = field(default=3)
     key: str = field(default="hill")
@@ -56,7 +54,7 @@ class GeneratorConfig:
         :return: BaseCipherAlgorithm: The primary algorithm used for the cipher
         """
         if self.algorithm.lower() not in self._cipher_registry:
-            raise exceptions.InvalidAlgorithmException(self.algorithm)
+            raise InvalidAlgorithmException(self.algorithm)
         return self._cipher_registry[self.algorithm.lower()]
 
     def replace_character(self, char: str, replacement: str) -> None:
@@ -77,53 +75,24 @@ class GeneratorConfig:
         """
         self.characters_replacements.pop(char, None)
 
-
-@dataclass
-class Generator:
-    id: UUID = field(default_factory=uuid4)
-    user_id: UUID = field(default_factory=uuid4)
-    created_at: datetime = field(default_factory=datetime.now)
-    updated_at: datetime = field(default_factory=datetime.now)
-    config_id: UUID = field(default_factory=UUID)
-    config: GeneratorConfig = field(default_factory=GeneratorConfig)
-    
-    def __post_init__(self):
-        self.config = GeneratorConfig(generator_id=self.id)
-
     def apply_replacements(self, password: str) -> str:
         """
         Replace character from the ciphered password with character replacements from the generator configurations
+        :param password: The password to perform the action on it
         :return: str: The new ciphered password after character replacements
         """
-        translation_table = str.maketrans(self.config.characters_replacements)
+        translation_table: dict[int, str] = str.maketrans(self.characters_replacements)
         return password.translate(translation_table)
 
     def generate_password(self, text: str) -> str:
         """
         Generate a strong password string using the raw password (add another layer of encryption to it)
+        :param text: The text to generate password from it
         :return: str: The generated ciphered password
         """
-        affine = AffineCipherAlgorithm(self.config.shift, self.config.multiplier)
-        intermediate = affine.encrypt(f"{self.config.prefix}{text}{self.config.postfix}")
-        main_algorithm = self.config.get_algorithm()
-        password = main_algorithm.encrypt(intermediate)
+        main_algorithm: BaseCipherAlgorithm = self.get_algorithm()
+        secondary_algorithm: AffineCipherAlgorithm = AffineCipherAlgorithm(self.shift, self.multiplier)
+        intermediate: str = secondary_algorithm.encrypt(f"{self.prefix}{text}{self.postfix}")
+        password: str = main_algorithm.encrypt(intermediate)
         password = self.apply_replacements(password)
         return ''.join(c.upper() if c in text else c for c in password)
-
-
-@dataclass
-class User:
-    id: UUID = field(default_factory=uuid4)
-    created_at: datetime = field(default_factory=datetime.now)
-    updated_at: datetime = field(default_factory=datetime.now)
-    username: str = field(default_factory=str)
-    email: str = field(default_factory=str)
-    password: str = field(default_factory=str)
-    generator_id: UUID = field(default_factory=UUID)
-    passwords_ids: list[UUID] = field(default_factory=list[UUID])
-
-    def add_password(self, password_id: UUID) -> None:
-        self.passwords_ids.append(password_id)
-
-    def delete_password(self, password_id: UUID) -> None:
-        self.passwords_ids.remove(password_id)

passphera_core-0.11.1/passphera_core/exceptions.py

@@ -0,0 +1,19 @@
+from passphera_core.entities import Password
+
+
+class PasswordNotFoundException(Exception):
+    def __init__(self) -> None:
+        super().__init__("Password not found")
+
+
+class DuplicatePasswordException(Exception):
+    def __init__(self, password: Password) -> None:
+        self.password = password
+        message = self._build_message(password)
+        super().__init__(message)
+
+    @staticmethod
+    def _build_message(password: Password) -> str:
+        if hasattr(password, 'context') and password.context:
+            return f"Password for context '{password.context}' already exists"
+        return "Duplicate password detected"

passphera_core-0.11.1/passphera_core/interfaces.py

@@ -0,0 +1,44 @@
+from abc import ABC, abstractmethod
+from uuid import UUID
+
+from passphera_core.entities import Password, Generator
+
+
+class PasswordRepository(ABC):
+    @abstractmethod
+    def save(self, password: Password) -> None:
+        pass
+
+    @abstractmethod
+    def get_by_context(self, context: str) -> Password:
+        pass
+
+    @abstractmethod
+    def update(self, password: Password) -> None:
+        pass
+
+    @abstractmethod
+    def delete(self, password: Password) -> None:
+        pass
+
+    @abstractmethod
+    def list(self) -> list[Password]:
+        pass
+
+    @abstractmethod
+    def flush(self) -> None:
+        pass
+
+
+class GeneratorRepository(ABC):
+    @abstractmethod
+    def save(self, generator: Generator) -> None:
+        pass
+
+    @abstractmethod
+    def get(self, generator_id: UUID) -> Generator:
+        pass
+
+    @abstractmethod
+    def update(self, generator: Generator) -> None:
+        pass

{passphera_core-0.10.0 → passphera_core-0.11.1}/passphera_core.egg-info/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.2
 Name: passphera-core
-Version: 0.10.0
+Version: 0.11.1
 Summary: The core system of passphera project
 Home-page: https://github.com/passphera/core
 Author: Fathi Abdelmalek
 Author-email: abdelmalek.fathi.2001@gmail.com
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python

{passphera_core-0.10.0 → passphera_core-0.11.1}/passphera_core.egg-info/SOURCES.txt

@@ -11,5 +11,4 @@ passphera_core.egg-info/requires.txt
 passphera_core.egg-info/top_level.txt
 passphera_core/application/__init__.py
 passphera_core/application/generator.py
-passphera_core/application/password.py
-passphera_core/application/user.py
+passphera_core/application/password.py

{passphera_core-0.10.0 → passphera_core-0.11.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name='passphera-core',
-    version='0.10.0',
+    version='0.11.1',
     author='Fathi Abdelmalek',
     author_email='abdelmalek.fathi.2001@gmail.com',
     url='https://github.com/passphera/core',
@@ -16,7 +16,7 @@ setup(
     python_requires='>=3',
     install_requires=['cipherspy'],
     classifiers=[
-        "Development Status :: 3 - Alpha",
+        "Development Status :: 4 - Beta",
         "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
         "Programming Language :: Python",

passphera_core-0.10.0/passphera_core/__init__.py

@@ -1,2 +0,0 @@
-from passphera_core.entities.generator import Generator
-from passphera_core.exceptions import InvalidAlgorithmException

passphera_core-0.10.0/passphera_core/application/generator.py

@@ -1,78 +0,0 @@
-from datetime import datetime, timezone
-from uuid import UUID
-
-from passphera_core.entities import Generator, GeneratorConfig
-from passphera_core.interfaces import GeneratorRepository, GeneratorConfigRepository
-
-
-class GetGeneratorUseCase:
-    def __init__(self, generator_repository: GeneratorRepository):
-        self.generator_repository: GeneratorRepository = generator_repository
-
-    def execute(self, user_id: UUID) -> Generator:
-        return self.generator_repository.find_by_user_id(user_id)
-    
-    
-class GetGeneratorConfigPropertyUseCase:
-    def __init__(self, generator_repository: GeneratorRepository, generator_config_repository: GeneratorConfigRepository):
-        self.generator_repository: GeneratorRepository = generator_repository
-        self.generator_config_repository: GeneratorConfigRepository = generator_config_repository
-
-    def execute(self, user_id: UUID, field: str) -> str:
-        generator_entity: Generator = self.generator_repository.find_by_user_id(user_id)
-        generator_config_entity: GeneratorConfig = self.generator_config_repository.find_by_generator_id(generator_entity.id)
-        return getattr(generator_config_entity, field)
-
-
-class UpdateGeneratorConfigUseCase:
-    def __init__(
-            self,
-            generator_repository: GeneratorRepository,
-            generator_config_repository: GeneratorConfigRepository,
-    ):
-        self.generator_repository: GeneratorRepository = generator_repository
-        self.generator_config_repository: GeneratorConfigRepository = generator_config_repository
-
-    def execute(self, user_id: UUID, field: str, value: str) -> None:
-        generator_entity: Generator = self.generator_repository.find_by_user_id(user_id)
-        generator_config_entity: GeneratorConfig = self.generator_config_repository.find_by_generator_id(generator_entity.id)
-        setattr(generator_config_entity, field, value)
-        if field == 'algorithm':
-            generator_config_entity.get_algorithm()
-        generator_config_entity.updated_at = datetime.now(timezone.utc)
-        self.generator_config_repository.update(generator_config_entity)
-
-
-
-class AddCharacterReplacementUseCase:
-    def __init__(
-            self,
-            generator_repository: GeneratorRepository,
-            generator_config_repository: GeneratorConfigRepository,
-    ):
-        self.generator_repository: GeneratorRepository = generator_repository
-        self.generator_config_repository: GeneratorConfigRepository = generator_config_repository
-
-    def execute(self, user_id: UUID, character: str, replacement: str) -> None:
-        generator_entity: Generator = self.generator_repository.find_by_user_id(user_id)
-        generator_config_entity: GeneratorConfig = self.generator_config_repository.find_by_generator_id(generator_entity.id)
-        generator_config_entity.replace_character(character, replacement)
-        generator_config_entity.updated_at = datetime.now(timezone.utc)
-        self.generator_config_repository.update(generator_config_entity)
-
-
-class ResetCharacterReplacementUseCase:
-    def __init__(
-            self,
-            generator_repository: GeneratorRepository,
-            generator_config_repository: GeneratorConfigRepository,
-    ):
-        self.generator_repository: GeneratorRepository = generator_repository
-        self.generator_config_repository: GeneratorConfigRepository = generator_config_repository
-
-    def execute(self, user_id: UUID, character: str) -> None:
-        generator_entity: Generator = self.generator_repository.find_by_user_id(user_id)
-        generator_config_entity: GeneratorConfig = self.generator_config_repository.find_by_generator_id(generator_entity.id)
-        generator_config_entity.reset_character(character)
-        generator_config_entity.updated_at = datetime.now(timezone.utc)
-        self.generator_config_repository.update(generator_config_entity)

passphera_core-0.10.0/passphera_core/application/password.py

@@ -1,118 +0,0 @@
-from datetime import datetime, timezone
-from uuid import UUID
-
-from passphera_core.entities import Password, Generator, User
-from passphera_core.exceptions import EntityNotFoundException
-from passphera_core.interfaces import PasswordRepository, GeneratorRepository, UserRepository
-
-
-class GeneratePasswordUseCase:
-    def __init__(
-            self,
-            password_repository: PasswordRepository,
-            generator_repository: GeneratorRepository,
-            user_repository: UserRepository
-    ):
-        self.password_repository: PasswordRepository = password_repository
-        self.generator_repository: GeneratorRepository = generator_repository
-        self.user_repository: UserRepository = user_repository
-
-    def execute(self, user_id: UUID, context: str, text: str) -> Password:
-        user_entity: User = self.user_repository.find_by_id(user_id)
-        generator_entity: Generator = self.generator_repository.find_by_id(user_entity.generator)
-        password: str = generator_entity.generate_password(text)
-        password_entity: Password = Password(user_id=user_id, context=context, text=text, password=password)
-        password_entity.encrypt()
-        self.password_repository.save(password_entity)
-        user_entity.add_password(password_entity.id)
-        self.user_repository.update(user_entity)
-        return password_entity
-
-
-class GetPasswordByIdUseCase:
-    def __init__(self, password_repository: PasswordRepository):
-        self.password_repository: PasswordRepository = password_repository
-
-    def execute(self, password_id: UUID) -> Password:
-        password_entity: Password = self.password_repository.find_by_id(password_id)
-        if not password_entity:
-            raise EntityNotFoundException(password_entity)
-        return password_entity
-
-
-class GetPasswordByContextUseCase:
-    def __init__(self, password_repository: PasswordRepository, user_repository: UserRepository):
-        self.password_repository: PasswordRepository = password_repository
-        self.user_repository: UserRepository = user_repository
-
-    def execute(self, user_id: UUID, context: str) -> Password:
-        user_entity: User = self.user_repository.find_by_id(user_id)
-        for password_id in user_entity.passwords:
-            password_entity: Password = self.password_repository.find_by_id(password_id)
-            if password_entity.context == context:
-                return password_entity
-        raise EntityNotFoundException(Password())
-
-
-class UpdatePasswordUseCase:
-    def __init__(
-            self,
-            password_repository: PasswordRepository,
-            generator_repository: GeneratorRepository,
-            user_repository: UserRepository
-    ):
-        self.password_repository: PasswordRepository = password_repository
-        self.generator_repository: GeneratorRepository = generator_repository
-        self.user_repository: UserRepository = user_repository
-
-    def execute(self, user_id: UUID, context: str, text: str) -> Password:
-        user_entity: User = self.user_repository.find_by_id(user_id)
-        generator_entity: Generator = self.generator_repository.find_by_id(user_entity.generator)
-        for password_id in user_entity.passwords:
-            password_entity: Password = self.password_repository.find_by_id(password_id)
-            if password_entity.context == context:
-                password_entity.password = generator_entity.generate_password(text)
-                password_entity.encrypt()
-                password_entity.updated_at = datetime.now(timezone.utc)
-                self.password_repository.update(password_entity)
-                return password_entity
-        raise EntityNotFoundException(Password())
-
-
-class DeletePasswordUseCase:
-    def __init__(self, password_repository: PasswordRepository, user_repository: UserRepository):
-        self.password_repository: PasswordRepository = password_repository
-        self.user_repository: UserRepository = user_repository
-
-    def execute(self, user_id: UUID, password_id: UUID) -> None:
-        self.password_repository.delete(password_id)
-        user_entity: User = self.user_repository.find_by_id(user_id)
-        user_entity.delete_password(password_id)
-        self.user_repository.update(user_entity)
-
-
-class GetAllUserPasswordsUseCase:
-    def __init__(self, password_repository: PasswordRepository, user_repository: UserRepository):
-        self.password_repository: PasswordRepository = password_repository
-        self.user_repository: UserRepository = user_repository
-
-    def execute(self, user_id: UUID) -> list[Password]:
-        user_entity: User = self.user_repository.find_by_id(user_id)
-        passwords: list[Password] = []
-        for password_id in user_entity.passwords:
-            password_entity: Password = self.password_repository.find_by_id(password_id)
-            passwords.append(password_entity)
-        return passwords
-
-
-class DeleteAllUserPasswordsUseCase:
-    def __init__(self, password_repository: PasswordRepository, user_repository: UserRepository):
-        self.password_repository: PasswordRepository = password_repository
-        self.user_repository: UserRepository = user_repository
-
-    def execute(self, user_id: UUID) -> None:
-        user_entity: User = self.user_repository.find_by_id(user_id)
-        for password_id in user_entity.passwords:
-            self.password_repository.delete(password_id)
-            user_entity.delete_password(password_id)
-        self.user_repository.update(user_entity)

passphera_core-0.10.0/passphera_core/application/user.py

@@ -1,56 +0,0 @@
-from uuid import UUID
-
-from passphera_core.entities import User, Generator
-from passphera_core.exceptions import DuplicateEntityException
-from passphera_core.interfaces import UserRepository, GeneratorRepository
-
-
-class RegisterUserUseCase:
-    def __init__(self, user_repository: UserRepository, generator_repository: GeneratorRepository):
-        self.user_repository: UserRepository = user_repository
-        self.generator_repository: GeneratorRepository = generator_repository
-
-    def execute(self, user: User) -> User:
-        if self.user_repository.find_by_email(user.email):
-            raise DuplicateEntityException(user, 'email')
-        if self.user_repository.find_by_username(user.username):
-            raise DuplicateEntityException(user, 'username')
-        user_entity: User = User(**user.__dict__)
-        generator_entity: Generator = Generator(user_id=user_entity.id)
-        self.generator_repository.save(generator_entity)
-        user_entity.generator_id = generator_entity.id
-        self.user_repository.save(user_entity)
-        return user_entity
-
-
-class GetUserByIdUseCase:
-    def __init__(self, user_repository: UserRepository):
-        self.user_repository: UserRepository = user_repository
-
-    def execute(self, id: UUID) -> User:
-        user = self.user_repository.find_by_id(id)
-        if not user:
-            raise ValueError(f'User not found')
-        return user
-
-
-class GetUserByUsernameUseCase:
-    def __init__(self, user_repository: UserRepository):
-        self.user_repository = user_repository
-
-    def execute(self, username: str) -> User:
-        user = self.user_repository.find_by_username(username)
-        if not user:
-            raise ValueError(f'User not found')
-        return user
-
-
-class GetUserByEmailUseCase:
-    def __init__(self, user_repository: UserRepository):
-        self.user_repository = user_repository
-
-    def execute(self, email: str) -> User:
-        user = self.user_repository.find_by_email(email)
-        if not user:
-            raise ValueError(f'User not found')
-        return user

passphera_core-0.10.0/passphera_core/exceptions.py

@@ -1,49 +0,0 @@
-from typing import Union, Literal
-
-from passphera_core.entities import Password, Generator, User
-
-
-class InvalidAlgorithmException(Exception):
-    def __init__(self, algorithm: str) -> None:
-        self.algorithm = algorithm
-        super().__init__(f"Invalid algorithm: '{algorithm}'")
-
-
-class EntityNotFoundException(Exception):
-    def __init__(self, entity: Union[Password, Generator, User]) -> None:
-        self.entity = entity
-        entity_type = entity.__class__.__name__
-        super().__init__(f"{entity_type} not found")
-
-
-class DuplicateEntityException(Exception):
-    def __init__(
-            self,
-            entity: Union[Password, User],
-            duplicate_field: Literal['context', 'email', 'username'] = None
-    ) -> None:
-        self.entity = entity
-        self.duplicate_field = duplicate_field
-        message = self._build_message(entity, duplicate_field)
-        super().__init__(message)
-
-    def _build_message(self, entity: Union[Password, User], duplicate_field: str | None) -> str:
-        if isinstance(entity, Password):
-            return self._build_password_message(entity)
-        elif isinstance(entity, User):
-            return self._build_user_message(entity, duplicate_field)
-        return "Duplicate entity detected"
-
-    @staticmethod
-    def _build_password_message(password: Password) -> str:
-        if hasattr(password, 'context') and password.context:
-            return f"Password for context '{password.context}' already exists"
-        return "Duplicate password detected"
-
-    @staticmethod
-    def _build_user_message(user: User, duplicate_field: str) -> str:
-        if duplicate_field == 'email':
-            return f"User with email '{user.email}' already exists"
-        elif duplicate_field == 'username':
-            return f"User with username '{user.username}' already exists"
-        return "Duplicate user detected"

passphera_core-0.10.0/passphera_core/interfaces.py

@@ -1,80 +0,0 @@
-from abc import ABC, abstractmethod
-from uuid import UUID
-
-from passphera_core.entities import Password, Generator, GeneratorConfig, User
-
-
-class PasswordRepository(ABC):
-    @abstractmethod
-    def save(self, password: Password) -> None:
-        pass
-
-    @abstractmethod
-    def update(self, password: Password) -> None:
-        pass
-
-    @abstractmethod
-    def delete(self, password_id: UUID) -> None:
-        pass
-
-    @abstractmethod
-    def find_by_id(self, password_id: UUID) -> Password:
-        pass
-
-
-class GeneratorRepository(ABC):
-    @abstractmethod
-    def save(self, generator: Generator) -> None:
-        pass
-
-    @abstractmethod
-    def update(self, generator: Generator) -> None:
-        pass
-
-    @abstractmethod
-    def find_by_id(self, generator_id: UUID) -> Generator:
-        pass
-
-    @abstractmethod
-    def find_by_user_id(self, user_id: UUID) -> Generator:
-        pass
-
-
-class GeneratorConfigRepository(ABC):
-    @abstractmethod
-    def save(self, generator_config: GeneratorConfig) -> None:
-        pass
-
-    @abstractmethod
-    def update(self, generator_config: GeneratorConfig) -> None:
-        pass
-
-    @abstractmethod
-    def find_by_id(self, generator_config_id: UUID) -> GeneratorConfig:
-        pass
-
-    @abstractmethod
-    def find_by_generator_id(self, generator_id: UUID) -> GeneratorConfig:
-        pass
-
-
-class UserRepository(ABC):
-    @abstractmethod
-    def save(self, user: User) -> None:
-        pass
-
-    @abstractmethod
-    def update(self, user: User) -> None:
-        pass
-
-    @abstractmethod
-    def find_by_id(self, user_id: UUID) -> User:
-        pass
-
-    @abstractmethod
-    def find_by_username(self, username: str) -> User:
-        pass
-
-    @abstractmethod
-    def find_by_email(self, email: str) -> User:
-        pass