passphera-core 0.30.2__py3-none-any.whl → 0.32.0__py3-none-any.whl

passphera_core/entities.py

@@ -1,23 +1,18 @@
 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.exceptions import InvalidAlgorithmException
-from cipherspy.utilities import generate_salt, derive_key
-
-from passphera_core.exceptions import InvalidPropertyNameException
 
+from passphera_core.utilities import check_property_name
 
-_cipher_registry: dict[str, BaseCipherAlgorithm] = {
+_cipher_registry: dict = {
     'caesar': CaesarCipherAlgorithm,
     'affine': AffineCipherAlgorithm,
     'playfair': PlayfairCipherAlgorithm,
     'hill': HillCipherAlgorithm,
 }
-_default_properties: dict[str, str] = {
+_default_properties: dict[str, object] = {
     "shift": 3,
     "multiplier": 3,
     "key": "hill",
@@ -27,63 +22,8 @@ _default_properties: dict[str, str] = {
 }
 
 
-@dataclass
-class Password:
-    id: UUID = field(default_factory=uuid4)
-    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
-    updated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
-    context: str = field(default_factory=str)
-    text: str = field(default_factory=str)
-    password: str = field(default_factory=str)
-    salt: bytes = field(default_factory=lambda: bytes)
-
-    def encrypt(self) -> None:
-        """
-        Encrypts the password using Fernet symmetric encryption.
-
-        This method generates a new salt, derives an encryption key using the password
-        and salt, and then encrypts the password using Fernet encryption. The encrypted
-        password is stored back in the password field as a base64-encoded string.
-        :return: 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:
-        """
-        Decrypts the encrypted password using Fernet symmetric decryption.
-
-        This method uses the stored salt to derive the encryption key and then
-        decrypts the stored encrypted password using Fernet decryption.
-        :return: str: The decrypted original password
-        """
-        key = derive_key(self.password, self.salt)
-        return Fernet(key).decrypt(self.password.encode()).decode()
-
-    def to_dict(self) -> dict:
-        """Convert the Password entity to a dictionary."""
-        return {
-            "id": self.id,
-            "created_at": self.created_at,
-            "updated_at": self.updated_at,
-            "context": self.context,
-            "text": self.text,
-            "password": self.password,
-            "salt": self.salt,
-        }
-
-    def from_dict(self, data: dict) -> None:
-        """Convert a dictionary to a Password entity."""
-        for key, value in data.items():
-            setattr(self, key, value)
-
-
 @dataclass
 class Generator:
-    id: UUID = field(default_factory=uuid4)
-    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
-    updated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
     shift: int = field(default=_default_properties["shift"])
     multiplier: int = field(default=_default_properties["multiplier"])
     key: str = field(default=_default_properties["key"])
@@ -133,6 +73,17 @@ class Generator:
             "characters_replacements": self.characters_replacements,
         }
 
+    @check_property_name
+    def get_property(self, prop: str):
+        """
+        Get the value of a specific generator property
+        :param prop: The property name to retrieve; must be one of: shift, multiplier, key, algorithm, prefix, postfix
+        :raises InvalidPropertyNameException: If the property name is not one of the allowed properties
+        :return: The value of the requested property
+        """
+        return getattr(self, prop)
+
+    @check_property_name
     def set_property(self, prop: str, value: str):
         """
         Update a generator property with a new value
@@ -141,28 +92,23 @@ class Generator:
         :raises ValueError: If the property name is not one of the allowed properties
         :return: None
         """
-        if prop not in {"id", "created_at", "updated_at", "shift", "multiplier", "key", "algorithm", "prefix", "postfix"}:
-            raise InvalidPropertyNameException(prop)
         if prop in ["shift", "multiplier"]:
             value = int(value)
         setattr(self, prop, value)
         if prop == "algorithm":
             self.get_algorithm()
-        self.updated_at = datetime.now(timezone.utc)
-        
-    def reset_property(self, prop: str):
+
+    @check_property_name
+    def reset_property(self, prop: str) -> None:
         """
         Reset a generator property to its default value
         :param prop: The property name to reset, it must be one of: shift, multiplier, key, algorithm, prefix, postfix
         :raises ValueError: If the property name is not one of the allowed properties
         :return: None
         """
-        if prop not in {"id", "created_at", "updated_at", "shift", "multiplier", "key", "algorithm", "prefix", "postfix"}:
-            raise InvalidPropertyNameException(prop)
         setattr(self, prop, _default_properties[prop])
         if prop == "algorithm":
             self.get_algorithm()
-        self.updated_at = datetime.now(timezone.utc)
         
     def get_character_replacement(self, character: str) -> str:
         """
@@ -172,7 +118,7 @@ class Generator:
         """
         return self.characters_replacements.get(character, character)
 
-    def replace_character(self, character: str, replacement: str) -> None:
+    def set_character_replacement(self, character: str, replacement: str) -> None:
         """
         Replace a character with another character or set of characters
         Eg: pg.replace_character('a', '@1')
@@ -181,16 +127,14 @@ class Generator:
         :return: None
         """
         self.characters_replacements[character[0]] = replacement
-        self.updated_at = datetime.now(timezone.utc)
 
-    def reset_character(self, character: str) -> None:
+    def reset_character_replacement(self, character: str) -> None:
         """
         Reset a character to its original value (remove its replacement from characters_replacements)
         :param character: The character to be reset to its original value
         :return: None
         """
         self.characters_replacements.pop(character, None)
-        self.updated_at = datetime.now(timezone.utc)
 
     def generate_password(self, text: str) -> str:
         """
@@ -201,25 +145,25 @@ class Generator:
         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(f"{self.prefix}{intermediate}{self.postfix}")
-        password = password.translate(str.maketrans(self.characters_replacements))
+        password: str = main_algorithm.encrypt(intermediate)
+        for char, repl in self.characters_replacements.items():
+            password = password.replace(char, repl)
         return ''.join(c.upper() if c in text else c for c in password)
 
     def to_dict(self) -> dict:
         """Convert the Generator entity to a dictionary."""
         return {
-            "id": self.id,
-            "created_at": self.created_at,
-            "updated_at": self.updated_at,
             "shift": self.shift,
             "multiplier": self.multiplier,
             "key": self.key,
             "algorithm": self.algorithm,
             "prefix": self.prefix,
             "postfix": self.postfix,
+            "character_replacements": self.characters_replacements,
         }
 
     def from_dict(self, data: dict) -> None:
         """Convert a dictionary to a Generator entity."""
         for key, value in data.items():
-            setattr(self, key, value)
+            if key in _default_properties or key == "characters_replacements":
+                setattr(self, key, value)

passphera_core/exceptions.py

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

passphera_core/utilities.py

@@ -1,20 +1,9 @@
-from datetime import datetime, timezone
+from passphera_core.exceptions import InvalidPropertyNameException
 
-from passphera_core.entities import Password, Generator
-from passphera_core.exceptions import DuplicatePasswordException
-from passphera_core.interfaces import VaultRepository
 
-
-def generate_password(entity: Password, generator: Generator) -> None:
-    entity.text = entity.text
-    entity.context = entity.context
-    entity.password = generator.generate_password(entity.text)
-    entity.updated_at = datetime.now(timezone.utc)
-    entity.encrypt()
-
-
-def get_password(password_repository: VaultRepository, context: str) -> Password:
-    password_entity: Password = password_repository.get(context)
-    if password_entity:
-        raise DuplicatePasswordException(password_entity)
-    return password_entity
+def check_property_name(func):
+    def wrapper(self, prop, *args, **kwargs):
+        if prop not in {"shift", "multiplier", "key", "algorithm", "prefix", "postfix", "character_replacements"}:
+            raise InvalidPropertyNameException(prop)
+        return func(self, prop, *args, **kwargs)
+    return wrapper

{passphera_core-0.30.2.dist-info → passphera_core-0.32.0.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: passphera-core
-Version: 0.30.2
-Summary: The core system of passphera project
+Version: 0.32.0
+Summary: The core of passphera project
 Home-page: https://github.com/passphera/core
 Author: Fathi Abdelmalek
-Author-email: abdelmalek.fathi.2001@gmail.com
+Author-email: passphera@imfathi.com
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

passphera_core-0.32.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+passphera_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+passphera_core/entities.py,sha256=uGKOMknwmHYb2zx26WS81bVMVeTZCRnP8A4NlL41GHM,6894
+passphera_core/exceptions.py,sha256=nb0iWLaFpFHEUjCa5dQ8UnIn3tZs8gN5dy2URgqJf0g,211
+passphera_core/utilities.py,sha256=2cu6qWu3iseCejStxk4vD35bhQfgvb1WWx0DzXEMp_w,382
+passphera_core-0.32.0.dist-info/METADATA,sha256=LirSsl3UaKonN1mnaHLTef9j-2esOAoSIZbDL6HdBjs,851
+passphera_core-0.32.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+passphera_core-0.32.0.dist-info/top_level.txt,sha256=aDUX2iWGOyfzyf6XakLWTbgeWqNrypMHO074Qratyds,15
+passphera_core-0.32.0.dist-info/RECORD,,

passphera_core/application/generator.py

@@ -1,70 +0,0 @@
-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 __call__(self) -> Generator:
-        return self.generator_repository.get()
-
-
-class GetPropertiesUseCase:
-    def __init__(self, generator_repository: GeneratorRepository):
-        self.generator_repository: GeneratorRepository = generator_repository
-
-    def __call__(self) -> dict:
-        return self.generator_repository.get().get_properties()
-
-
-class SetPropertyUseCase:
-    def __init__(self, generator_repository: GeneratorRepository):
-        self.generator_repository: GeneratorRepository = generator_repository
-
-    def __call__(self, prop: str, value: str) -> Generator:
-        generator_entity: Generator = self.generator_repository.get()
-        generator_entity.set_property(prop, value)
-        self.generator_repository.update(generator_entity)
-        return generator_entity
-
-
-class ResetPropertyUseCase:
-    def __init__(self, generator_repository: GeneratorRepository):
-        self.generator_repository: GeneratorRepository = generator_repository
-
-    def __call__(self, prop: str) -> Generator:
-        generator_entity: Generator = self.generator_repository.get()
-        generator_entity.reset_property(prop)
-        self.generator_repository.update(generator_entity)
-        return generator_entity
-
-
-class GetCharacterReplacementUseCase:
-    def __init__(self, generator_repository: GeneratorRepository):
-        self.generator_repository: GeneratorRepository = generator_repository
-
-    def __call__(self, character: str) -> str:
-        return self.generator_repository.get().get_character_replacement(character)
-
-
-class SetCharacterReplacementUseCase:
-    def __init__(self, generator_repository: GeneratorRepository):
-        self.generator_repository: GeneratorRepository = generator_repository
-
-    def __call__(self, character: str, replacement: str) -> Generator:
-        generator_entity: Generator = self.generator_repository.get()
-        generator_entity.replace_character(character, replacement)
-        self.generator_repository.update(generator_entity)
-        return generator_entity
-
-
-class ResetCharacterReplacementUseCase:
-    def __init__(self, generator_repository: GeneratorRepository,):
-        self.generator_repository: GeneratorRepository = generator_repository
-
-    def __call__(self, character: str) -> Generator:
-        generator_entity: Generator = self.generator_repository.get()
-        generator_entity.reset_character(character)
-        self.generator_repository.update(generator_entity)
-        return generator_entity

passphera_core/application/password.py

@@ -1,73 +0,0 @@
-from passphera_core.entities import Password, Generator
-from passphera_core.exceptions import DuplicatePasswordException
-from passphera_core.interfaces import VaultRepository, GeneratorRepository
-from passphera_core.utilities import generate_password, get_password
-
-
-class GeneratePasswordUseCase:
-    def __init__(
-            self,
-            password_repository: VaultRepository,
-            generator_repository: GeneratorRepository,
-    ):
-        self.password_repository: VaultRepository = password_repository
-        self.generator_repository: GeneratorRepository = generator_repository
-
-    def __call__(self, context: str, text: str) -> Password:
-        password_entity: Password = self.password_repository.get(context)
-        if password_entity:
-            raise DuplicatePasswordException(password_entity)
-        password_entity: Password = Password(context=context, text=text)
-        generator_entity: Generator = self.generator_repository.get()
-        generate_password(password_entity, generator_entity)
-        self.password_repository.save(password_entity)
-        return password_entity
-
-
-class GetPasswordUseCase:
-    def __init__(self, password_repository: VaultRepository):
-        self.password_repository: VaultRepository = password_repository
-
-    def __call__(self, context: str) -> Password:
-        return get_password(self.password_repository, context)
-
-
-class UpdatePasswordUseCase:
-    def __init__(
-            self,
-            password_repository: VaultRepository,
-            generator_repository: GeneratorRepository,
-    ):
-        self.password_repository: VaultRepository = password_repository
-        self.generator_repository: GeneratorRepository = generator_repository
-
-    def __call__(self, context: str, text: str) -> Password:
-        password_entity: Password = get_password(self.password_repository, context)
-        generator_entity: Generator = self.generator_repository.get()
-        generate_password(password_entity, generator_entity)
-        self.password_repository.update(password_entity)
-        return password_entity
-
-
-class DeletePasswordUseCase:
-    def __init__(self, password_repository: VaultRepository):
-        self.password_repository: VaultRepository = password_repository
-
-    def __call__(self, context: str) -> None:
-        self.password_repository.delete(get_password(self.password_repository, context))
-
-
-class ListPasswordsUseCase:
-    def __init__(self, password_repository: VaultRepository):
-        self.password_repository: VaultRepository = password_repository
-
-    def __call__(self) -> list[Password]:
-        return self.password_repository.list()
-
-
-class FlushPasswordsUseCase:
-    def __init__(self, password_repository: VaultRepository):
-        self.password_repository: VaultRepository = password_repository
-
-    def __call__(self) -> None:
-        self.password_repository.flush()

passphera_core/interfaces.py

@@ -1,43 +0,0 @@
-from abc import ABC, abstractmethod
-
-from passphera_core.entities import Password, Generator
-
-
-class VaultRepository(ABC):
-    @abstractmethod
-    def save(self, password: Password) -> None:
-        pass
-
-    @abstractmethod
-    def get(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:
-        pass
-
-    @abstractmethod
-    def update(self, generator: Generator) -> None:
-        pass

passphera_core-0.30.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-passphera_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-passphera_core/entities.py,sha256=sZYUQC7yGwsQ4ughai_QG_-TN-sVEMCpaBi8SJ0uyts,9321
-passphera_core/exceptions.py,sha256=Tqb-FKJ1_JfX5gSC8Wc0CP84AhwouvnP2gkg83xAlUY,786
-passphera_core/interfaces.py,sha256=DpHFh_vnamORf69P1dwLrZ8AYZPcYIol0Lq_VKRBkXc,855
-passphera_core/utilities.py,sha256=n7cAVox-yGd60595RjLvrGKSGqFQRm279YqKS3-R1X0,748
-passphera_core/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-passphera_core/application/generator.py,sha256=hBSk6vktJ2KPxzKSRnH_WVnCvg7vOHVzN-TQ5GdgXEQ,2769
-passphera_core/application/password.py,sha256=9wsSz3uMWEZCgfnX5V7WYiWp2OqjSmsn6OSWK4HIIfo,2876
-passphera_core-0.30.2.dist-info/METADATA,sha256=5-jCeM8j_Yx0Q0EaWtc_knE22pK78rv7o9xIRc5Szc4,868
-passphera_core-0.30.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-passphera_core-0.30.2.dist-info/top_level.txt,sha256=aDUX2iWGOyfzyf6XakLWTbgeWqNrypMHO074Qratyds,15
-passphera_core-0.30.2.dist-info/RECORD,,