fix: python typing issues

Author: LVivona

binding/python/py/synlink/crypto/ed25519.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from dataclasses import dataclass
 from typing import Optional, Tuple
 
@@ -6,20 +7,15 @@
 from nacl.public import PrivateKey as ImplPrivateKey
 
 from nacl.signing import SigningKey, VerifyKey
-from nacl.encoding import HexEncoder
+from nacl.encoding import HexEncoder, Encoder
 from synlink.crypto.exception import (
     CryptoBaseException,
     SignatureVerificationError,
 )
 from synlink.crypto.kind import Kind
 from synlink.crypto.typing import PrivateKey as IPrivateKey
 from synlink.crypto.typing import PublicKey as IPublicKey
-from synlink.utils import _check_minimum_version
-
-if _check_minimum_version(3, 11, 0):
-    from typing import Self
-else:
-    from typing_extensions import Self
+from synlink.crypto.typing import KeyPair as IKeyPair
 
 Message = bytes
 Signiture = bytes
@@ -32,6 +28,7 @@
     "create_new_ed25519_key_pair_from_seed",
 ]
 
+
 class PublicKey(IPublicKey):
     """
     Represents an ED25519 public key, providing methods for verification
@@ -45,26 +42,29 @@ def __init__(self, impl: VerifyKey):
         Args:
             impl: An instance of nacl.signing.VerifyKey.
         """
-        super().__init__()
         self._impl: VerifyKey = impl
         self._kind = Kind.ED25519
+
     def get_kind(self) -> Kind:
         """
         Returns the kind of this cryptographic key.
         """
         return self._kind
+
     def to_bytes(self) -> bytes:
         """
         Converts the public key to its raw byte representation.
         """
         return bytes(self._impl)
+
     def __bytes__(self) -> bytes:
         """
         Allows the PublicKey object to be converted to bytes using bytes().
         """
         return self.to_bytes()
+
     @classmethod
-    def from_bytes(cls, data: bytes) -> Self:
+    def from_bytes(cls, data: bytes) -> "PublicKey":
         """
         Creates a PublicKey object from its raw byte representation.
 
@@ -75,6 +75,7 @@ def from_bytes(cls, data: bytes) -> Self:
             A new PublicKey instance.
         """
         return cls(VerifyKey(data))
+
     def try_verify(self, data: bytes, signature: bytes) -> bool:
         """
         Attempts to verify the signature against the signed message.
@@ -97,6 +98,7 @@ def try_verify(self, data: bytes, signature: bytes) -> bool:
             raise SignatureVerificationError(f"{e}") from e
         except Exception as e:
             raise CryptoBaseException(f"{e}") from e
+
     def verify(self, data: bytes, signature: bytes) -> bool:
         """
         Verifies the signature against the signed message.
@@ -114,26 +116,31 @@ def verify(self, data: bytes, signature: bytes) -> bool:
             return True
         except BadSignatureError:
             return False
-        except Exception as e:
+        except Exception:
             # Catch other potential exceptions during verification
             # print(f"An unexpected error occurred during verification: {e}") # For debugging
             return False
+
     def __str__(self) -> str:
         """
         Returns a human-readable string representation of the public key.
         """
-        output = self._impl.encode(encoder=HexEncoder()).decode("utf-8")
+        encoder: Encoder = HexEncoder
+        output = self._impl.encode(encoder).decode("utf-8")
         return f"PublicKey({output})"
+
     def __repr__(self) -> str:
         """
         Returns a detailed string representation for debugging.
         """
-        output = self._impl.encode(encoder=HexEncoder()).decode("utf-8")
+        encoder: Encoder = HexEncoder
+        output = self._impl.encode(encoder).decode("utf-8")
         # Show a truncated hex representation for brevity in repr
         return (
             f"<synlink.crypto.ed25519.PublicKey {output[:8]}...{output[-8:]}>"
         )
 
+
 class PrivateKey(IPrivateKey):
     """
     Represents an ED25519 private key, providing methods for signing
@@ -147,16 +154,17 @@ def __init__(self, impl: SigningKey):
         Args:
             impl: An instance of nacl.signing.SigningKey.
         """
-        super().__init__()
         self._kind = Kind.ED25519
         self._impl: SigningKey = impl
+
     def get_kind(self) -> Kind:
         """
         Returns the kind of this cryptographic key.
         """
         return self._kind
+
     @classmethod
-    def generate(cls) -> Self:
+    def generate(cls) -> "PrivateKey":
         """
         Generates a new random ED25519 private key.
 
@@ -165,8 +173,9 @@ def generate(cls) -> Self:
         """
         impl = SigningKey.generate()
         return cls(impl)
+
     @classmethod
-    def from_seed(cls, seed: Optional[bytes] = None) -> Self:
+    def from_seed(cls, seed: Optional[bytes] = None) -> "PrivateKey":
         """
         Generates an ED25519 private key from a 32-byte seed.
 
@@ -189,8 +198,9 @@ def from_seed(cls, seed: Optional[bytes] = None) -> Self:
         ), "PrivateKey seed must be a 32 bytes long binary sequence"
         impl = ImplPrivateKey.from_seed(seed)
         return cls(SigningKey(bytes(impl)))
+
     @classmethod
-    def from_bytes(cls, data: bytes) -> Self:
+    def from_bytes(cls, data: bytes) -> "PrivateKey":
         """
         Creates an ED25519 private key from its raw byte representation.
 
@@ -202,6 +212,7 @@ def from_bytes(cls, data: bytes) -> Self:
         """
         impl = SigningKey(data)
         return cls(impl)
+
     def get_public_key(self) -> IPublicKey:
         """
         Returns the public key corresponding to this private key.
@@ -210,6 +221,7 @@ def get_public_key(self) -> IPublicKey:
             raise CryptoBaseException("Invalid private key implementation.")
         # Return a PublicKey wrapping the VerifyKey derived from this SigningKey
         return PublicKey(self._impl.verify_key)
+
     def sign(self, data: bytes) -> Tuple[Message, Signiture]:
         """
         Signs data with the private key and returns the raw signature.
@@ -225,37 +237,42 @@ def sign(self, data: bytes) -> Tuple[Message, Signiture]:
         # Direct signing using the wrapped SigningKey
         signed_message = self._impl.sign(data)
         return signed_message.message, signed_message.signature
+
     def to_bytes(self) -> bytes:
         """
         Converts the private key to its raw byte representation.
         """
         return bytes(self._impl)
+
     def __bytes__(self) -> bytes:
         """
         Allows the PrivateKey object to be converted to bytes using bytes().
         """
         return self.to_bytes()
+
     def __str__(self) -> str:
         """
         Returns a human-readable string representation of the private key.
         """
         # For security, avoid showing private key material in str.
         return "PrivateKey(ED25519)"
+
     def __repr__(self) -> str:
         """
         Returns a detailed string representation for debugging.
         """
         # For security, avoid showing private key material in repr.
         return "<synlink.crypto.ed25519.PrivateKey>"
 
+
 @dataclass(frozen=True, repr=False)
-class KeyPair(object):
+class KeyPair(IKeyPair):
     """
     Represents an ED25519 key pair, containing both a private and public key.
     """
 
     secret: PrivateKey
-    public: PublicKey
+    public: IPublicKey
 
     def try_verify(self, message: bytes, signature: bytes) -> bool:
         """
@@ -273,6 +290,7 @@ def try_verify(self, message: bytes, signature: bytes) -> bool:
             Exception: base class for all non-exit exceptions.
         """
         return self.public.try_verify(data=message, signature=signature)
+
     def verify(self, message: bytes, signature: bytes) -> bool:
         """
         Verifies the signature against the signed message.
@@ -288,6 +306,7 @@ def verify(self, message: bytes, signature: bytes) -> bool:
             return self.public.verify(data=message, signature=signature)
         except BadSignatureError:
             return False
+
     def sign(self, message: bytes) -> Tuple[Message, Signiture]:
         """
         Signs data with the private key and returns the raw signature.
@@ -299,18 +318,21 @@ def sign(self, message: bytes) -> Tuple[Message, Signiture]:
             The raw signature bytes.
         """
         return self.secret.sign(data=message)
+
     def __bytes__(self) -> bytes:
         """
         Returns the raw bytes of the secret (private) key.
         """
         return bytes(self.secret)
+
     def __repr__(self) -> str:
         """
         Returns a detailed string representation for debugging.
         """
         # Include the public key's repr for better context
         return f"<synlink.crypto.ed25519.KeyPair public={self.public!s}>"
 
+
 def create_new_ed25519_key_pair() -> KeyPair:
     """
     Creates a new ED25519 key pair with randomly generated keys.
@@ -320,7 +342,8 @@ def create_new_ed25519_key_pair() -> KeyPair:
     """
     secret = PrivateKey.generate()
     public = secret.get_public_key()
-    return KeyPair(secret, public)
+    return KeyPair(secret=secret, public=public)
+
 
 def create_new_ed25519_key_pair_from_seed(
     seed: Optional[bytes] = None,
@@ -338,4 +361,4 @@ def create_new_ed25519_key_pair_from_seed(
     """
     secret: PrivateKey = PrivateKey.from_seed(seed)
     public = secret.get_public_key()
-    return KeyPair(secret, public)
+    return KeyPair(secret=secret, public=public)

binding/python/py/synlink/crypto/exception.py

@@ -1,10 +1,12 @@
 from synlink.error import SynlinkBaseException
 
+
 class CryptoBaseException(SynlinkBaseException):
     """Base exception for all cryptographic errors."""
 
     pass
 
+
 class SignatureVerificationError(CryptoBaseException):
     """Raised when signature verification fails."""
 

binding/python/py/synlink/crypto/io.py

@@ -1,7 +1,6 @@
 import os
-import pathlib
 
-from typing import Union, Optional
+from typing import Union, Optional, Final
 
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric import (
@@ -10,11 +9,10 @@
 
 import synlink.crypto.ed25519 as ed25519
 from synlink.crypto.typing import KeyPair
+from synlink.utils import HOME_DIR
 
-HOME_DIR: str = pathlib.Path.home().__str__()
-SSH_DEFAULT_DIRECTORY = os.path.join(HOME_DIR, ".ssh")
+SSH_DEFAULT_DIRECTORY: Final[str] = os.path.join(HOME_DIR, ".ssh")
 
-__all__ = ["load_open_ssh_private_key"]
 
 def load_ssh_private_key(
     file: Union[str, os.PathLike] = SSH_DEFAULT_DIRECTORY,
@@ -54,4 +52,4 @@ def load_ssh_private_key(
             public = secret.get_public_key()
             return ed25519.KeyPair(secret=secret, public=public)
         else:
-            raise NotImplemented
+            raise NotImplementedError("key type is not implmented.")

binding/python/py/synlink/crypto/kind.py

@@ -1,14 +1,16 @@
 from enum import Enum
-from functools import cache
+
 
 class Kind(Enum):
-    ED25519: int = 0
+    ED25519 = 0
 
     def to_string(self) -> str:
         """return the name of the crypto kind."""
         return self.name
+
     def to_bytes(self) -> bytes:
         return self.value.to_bytes(1, byteorder="little")
+
     @classmethod
     def from_bytes(cls, data: bytes) -> "Kind":
         """return kind from the byte(s)"""
@@ -18,17 +20,22 @@ def from_bytes(cls, data: bytes) -> "Kind":
         elif num < cls.min():
             raise ValueError(f"bytes shound not be less then {cls.min()}")
         return cls(num)
+
     @staticmethod
     def max() -> int:
         """return the maximum possible enumeration number."""
         return 0
+
     @staticmethod
     def min() -> int:
         """return the maximum possible enumeration number."""
         return 0
+
     def __bytes__(self) -> bytes:
         return self.to_bytes()
+
     def __str__(self) -> str:
         return self.to_string()
+
     def __repr__(self) -> str:
         return f"<synlink.crypto.kind kind={self}>"