passphera-core 0.8.2__py3-none-any.whl → 0.9.1__py3-none-any.whl

passphera_core/__init__.py

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

passphera_core/application/generator.py

@@ -0,0 +1,78 @@
+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/application/password.py

@@ -0,0 +1,118 @@
+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/application/user.py

@@ -0,0 +1,56 @@
+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 = 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/entities.py

@@ -0,0 +1,125 @@
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from uuid import UUID, uuid4
+
+from cryptography.fernet import Fernet
+
+from cipherspy.cipher import *
+from cipherspy.cipher.base_cipher import BaseCipherAlgorithm
+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))
+    context: str = field(default_factory=str)
+    text: str = field(default_factory=str)
+    password: str = field(default_factory=str)
+    salt: bytes = field(default_factory=bytes)
+
+    def encrypt(self) -> None:
+        self.salt = generate_salt()
+        key = derive_key(self.password, self.salt)
+        self.password = Fernet(key).encrypt(self.password.encode()).decode()
+
+    def decrypt(self) -> str:
+        key = derive_key(self.password, self.salt)
+        return Fernet(key).decrypt(self.password.encode()).decode()
+
+
+@dataclass
+class GeneratorConfig:
+    id: UUID = field(default_factory=uuid4)
+    generator_id: UUID = field(default_factory=uuid4)
+    shift: int = field(default=3)
+    multiplier: int = field(default=3)
+    key: str = field(default="hill")
+    algorithm: str = field(default="hill")
+    prefix: str = field(default="secret")
+    postfix: str = field(default="secret")
+    characters_replacements: dict[str, str] = field(default_factory=dict[str, str])
+    _cipher_registry: dict[str, BaseCipherAlgorithm] = field(default_factory=lambda: {
+        'caesar': CaesarCipherAlgorithm,
+        'affine': AffineCipherAlgorithm,
+        'playfair': PlayfairCipherAlgorithm,
+        'hill': HillCipherAlgorithm,
+    }, init=False)
+
+    def get_algorithm(self) -> BaseCipherAlgorithm:
+        """
+        Get the primary algorithm used to cipher the password
+        :return: BaseCipherAlgorithm: The primary algorithm used for the cipher
+        """
+        if self.algorithm.lower() not in self._cipher_registry:
+            raise exceptions.InvalidAlgorithmException(self.algorithm)
+        return self._cipher_registry[self.algorithm.lower()]
+
+    def replace_character(self, char: str, replacement: str) -> None:
+        """
+        Replace a character with another character or set of characters
+        Eg: pg.replace_character('a', '@1')
+        :param char: The character to be replaced
+        :param replacement: The (character|set of characters) to replace the first one
+        :return:
+        """
+        self.characters_replacements[char[0]] = replacement
+
+    def reset_character(self, char: str) -> None:
+        """
+        Reset a character to its original value (remove its replacement from characters_replacements)
+        :param char: The character to be reset to its original value
+        :return:
+        """
+        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: GeneratorConfig = field(default_factory=GeneratorConfig)
+
+    def apply_replacements(self, password: str) -> str:
+        """
+        Replace character from the ciphered password with character replacements from the generator configurations
+        :return: str: The new ciphered password after character replacements
+        """
+        translation_table = str.maketrans(self.config.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)
+        :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)
+        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: UUID = field(default_factory=UUID)
+    passwords: list[UUID] = field(default_factory=list[UUID])
+
+    def add_password(self, password_id: UUID) -> None:
+        self.passwords.append(password_id)
+
+    def delete_password(self, password_id: UUID) -> None:
+        self.passwords.remove(password_id)

passphera_core/exceptions.py

@@ -1,3 +1,49 @@
+from typing import Union, Literal
+
+from passphera_core.entities import Password, Generator, User
+
+
 class InvalidAlgorithmException(Exception):
     def __init__(self, algorithm: str) -> None:
-        super().__init__(f"Invalid algorithm name [{algorithm}]")
+        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/interfaces.py

@@ -0,0 +1,92 @@
+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 delete(self, generator_id: UUID) -> 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 delete(self, generator_config_id: UUID) -> 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 delete(self, user_id: UUID) -> 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

{passphera_core-0.8.2.dist-info → passphera_core-0.9.1.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: passphera-core
-Version: 0.8.2
+Version: 0.9.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 :: 2 - Pre-Alpha
+Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python

passphera_core-0.9.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+passphera_core/__init__.py,sha256=0kEfHV5WvMWDoFn1qCeuD52WsgaX4sQ4V9P48cnFKb8,120
+passphera_core/entities.py,sha256=SvzBKDx9NkaVunXBGT-PgEWbXNXivb8pGw9Q_KFtAgI,5021
+passphera_core/exceptions.py,sha256=5NvV6LW4Pdok6gRxvM0cN3q6JEKgaCYAX8qGr2eqX2w,1890
+passphera_core/interfaces.py,sha256=uwHjPd1uhnA02X9h39IrHuNS-_M8j_RyKMVdxi3DUak,2036
+passphera_core/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+passphera_core/application/generator.py,sha256=ABUigLMtP52CHpTKIZmwNb0pgGeL4s_WgrpxLr1M9zw,3896
+passphera_core/application/password.py,sha256=72PXsHsSYvBDLdzwtC8icwf8KZPScWBKb9jKIQRAkEg,5511
+passphera_core/application/user.py,sha256=WTDjccHjxoqsfC2j0c9MfwREmiST9XxYOHoaDWYGTcg,2066
+passphera_core-0.9.1.dist-info/METADATA,sha256=jwBmrk5oor-rOcC6PSjASjC00mpNFHc3PifeR3uKZ44,671
+passphera_core-0.9.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+passphera_core-0.9.1.dist-info/top_level.txt,sha256=aDUX2iWGOyfzyf6XakLWTbgeWqNrypMHO074Qratyds,15
+passphera_core-0.9.1.dist-info/RECORD,,

{passphera_core-0.8.2.dist-info → passphera_core-0.9.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

passphera_core/generator.py

@@ -1,228 +0,0 @@
-from cipherspy.cipher import *
-
-from .exceptions import InvalidAlgorithmException
-
-
-class PasswordGenerator:
-    """
-    A strong password generator use multiple cipher algorithms to cipher a given plain text
-    """
-    def __init__(
-            self,
-            shift: int = 3,
-            multiplier: int = 3,
-            key: str = "hill",
-            algorithm: str = 'hill',
-            prefix: str = 'secret',
-            postfix: str = 'secret',
-            characters_replacements: dict = None,
-    ):
-        """
-        :param shift: number of characters to shift each character (default 3)
-        :param multiplier: number of characters to shift each character (default 3)
-        :param key: cipher key string (default "secret")
-        :param algorithm: main cipher algorithm name (default 'playfair')
-        :param characters_replacements: replace characters with the given values (default {})
-        :param text: plain text to be ciphered
-        """
-        if characters_replacements is None:
-            characters_replacements = {}
-        self._shift: int = shift
-        self._multiplier: int = multiplier
-        self._key: str = key
-        self._algorithm_name: str = algorithm.lower()
-        self._algorithm = self._set_algorithm()
-        self._prefix: str = prefix
-        self._postfix: str = postfix
-        self._characters_replacements: dict = characters_replacements
-
-    @property
-    def shift(self) -> int:
-        """
-        Returns the shift value for the cipher algorithm
-        Eg: ```shift = pg.shift```
-        :return: int: The shift value for the cipher algorithm
-        """
-        return self._shift
-
-    @shift.setter
-    def shift(self, shift: int) -> None:
-        """
-        Sets the shift value for the cipher algorithm
-        Eg: ```pg.shift = 3```
-        :param shift: The shift value for the cipher algorithm
-        :return:
-        """
-        self._shift = shift
-
-    @property
-    def multiplier(self) -> int:
-        """
-        Returns the multiplier value for the cipher algorithm
-        Eg: ```multiplier = pg.multiplier```
-        :return: int: The multiplier value for the cipher algorithm
-        """
-        return self._multiplier
-
-    @multiplier.setter
-    def multiplier(self, multiplier: int) -> None:
-        """
-        Sets the multiplier value for the cipher algorithm
-        Eg: ```pg.multiplier = 3```
-        :param multiplier: The multiplier value for the cipher algorithm
-        :return:
-        """
-        self._multiplier = multiplier
-
-    @property
-    def key(self) -> str:
-        """
-        Returns the key string for the cipher algorithm
-        Eg: ```key = pg.key```
-        :return: str: The key string for the cipher algorithm
-        """
-        return self._key
-
-    @key.setter
-    def key(self, key: str) -> None:
-        """
-        Sets the key string for the cipher algorithm
-        Eg: ```pg.key = 'secret key'```
-        :param key: The key string for the cipher algorithm
-        :return:
-        """
-        self._key = key
-
-    @property
-    def prefix(self) -> str:
-        """
-        Returns the prefix string for the cipher algorithm
-        Eg: ```prefix = pg.prefix```
-        :return: str: The prefix string for the cipher algorithm
-        """
-        return self._prefix
-
-    @prefix.setter
-    def prefix(self, prefix: str):
-        """
-        Sets the prefix string for the cipher algorithm
-        Eg: ```pg.prefix = 'something'```
-        :param prefix: The string for the cipher algorithm
-        :return:
-        """
-        self._prefix = prefix
-
-    @property
-    def postfix(self) -> str:
-        """
-        Returns the postfix string for the cipher algorithm
-        Eg: ```postfix = pg.postfix```
-        :return: str: The postfix string for the cipher algorithm
-        """
-        return self._postfix
-
-    @postfix.setter
-    def postfix(self, postfix: str):
-        """
-        Sets the postfix string for the cipher algorithm
-        Eg: ```pg.postfix = 'something'```
-        :param postfix: The string for the cipher algorithm
-        :return:
-        """
-        self._postfix = postfix
-
-    @property
-    def algorithm(self) -> str:
-        """
-        Returns the main cipher algorithm name
-        Eg: ```algorithm = pg.algorithm```
-        :return: str: The main cipher algorithm name
-        """
-        return self._algorithm_name
-
-    @algorithm.setter
-    def algorithm(self, algorithm: str) -> None:
-        """
-        Sets the main cipher algorithm
-        Eg: ```pg.algorithm = 'playfair'```
-        :param algorithm: The name of the main cipher algorithm
-        :return:
-        """
-        self._algorithm_name = algorithm.lower()
-        self._algorithm = self._set_algorithm()
-
-    @property
-    def characters_replacements(self) -> dict:
-        """
-        Returns the dictionary of the characters replacements
-        Eg: ```print(pg.characters_replacements)  # {'a': '@1', 'b': '#2'}```
-        :return: dict: The dictionary of the characters replacements
-        """
-        return self._characters_replacements
-
-    def _set_algorithm(self):
-        """
-        Return new instance of the used algorithm to the given one by it's name
-        :return: new algorithm class
-        """
-        match self._algorithm_name:
-            case 'caesar':
-                return CaesarCipher(self._shift)
-            case 'affine':
-                return AffineCipher(self._shift, self._multiplier)
-            case 'playfair':
-                return PlayfairCipher(self._key)
-            case 'hill':
-                return HillCipher(self._key)
-            case _:
-                raise InvalidAlgorithmException(self._algorithm_name)
-
-    def _update_algorithm_properties(self) -> None:
-        """
-        Update the main cipher algorithm
-        """
-        self._algorithm = self._set_algorithm()
-
-    def replace_character(self, char: str, replacement: str) -> None:
-        """
-        Replace a character with another character or set of characters
-        Eg: pg.replace_character('a', '@1')
-        :param char: The character to be replaced
-        :param replacement: The (character|set of characters) to replace the first one
-        :return:
-        """
-        self._characters_replacements[char[0]] = replacement
-
-    def reset_character(self, char: str) -> None:
-        """
-        Reset a character to it's original value (remove it's replacement from characters_replacements)
-        :param char: The character to be reset to its original value
-        :return:
-        """
-        if char in self._characters_replacements:
-            del self._characters_replacements[char]
-
-    def generate_raw_password(self, text: str) -> str:
-        """
-        Generate a raw password string using the given parameters
-        :return: str: The generated raw password
-        """
-        self._update_algorithm_properties()
-        return self._algorithm.encrypt(f"{self._prefix}{text}{self._postfix}")
-
-    def generate_password(self, text: str) -> str:
-        """
-        Generate a strong password string using the raw password (add another layer of encryption to it)
-        :return: str: The generated strong password
-        """
-        old_algorithm = self._algorithm_name
-        self._algorithm_name = 'affine'
-        password = self.generate_raw_password(text)
-        self._algorithm_name = old_algorithm
-        password = self.generate_raw_password(password)
-        for char, replacement in self._characters_replacements.items():
-            password = password.replace(char, replacement)
-        for char in password:
-            if char in text:
-                password = password.replace(char, char.upper())
-        return password

passphera_core-0.8.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-passphera_core/__init__.py,sha256=ND2D_sTQk5mroNRsKm03PXhx0HNf0740hOtZ4_U98OQ,119
-passphera_core/exceptions.py,sha256=PPZhy05QMVnN3mm6EGj-RgWanMaF3E6aKN4lcpNOJY8,158
-passphera_core/generator.py,sha256=O255qvsmanrj9BmJX-JxpT5iMFd1iEz2ewJC-r5O1WQ,7726
-passphera_core-0.8.2.dist-info/METADATA,sha256=2K4lTWVwrrttr61xA84AZrB6uSD7A1oncNJk-IUOKJE,675
-passphera_core-0.8.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-passphera_core-0.8.2.dist-info/top_level.txt,sha256=aDUX2iWGOyfzyf6XakLWTbgeWqNrypMHO074Qratyds,15
-passphera_core-0.8.2.dist-info/RECORD,,