otdf-python 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

{otdf_python-0.9.0.dist-info → otdf_python-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: otdf-python
-Version: 0.9.0
+Version: 0.10.0
 Summary: Unofficial OpenTDF SDK for Python
 Project-URL: Homepage, https://github.com/b-long/opentdf-python-sdk
 Project-URL: Repository, https://github.com/b-long/opentdf-python-sdk

{otdf_python-0.9.0.dist-info → otdf_python-0.10.0.dist-info}/RECORD

@@ -1,52 +1,3 @@
-otdf_python/__init__.py,sha256=q93tKt2r5-_244iKPeJf4ja1ftlmOmdRQnXWAZsxISI,542
-otdf_python/__main__.py,sha256=VuImcvrzCHTYOwQ-yS9HQwKmF2O6lORf1psmOkdZIh0,275
-otdf_python/address_normalizer.py,sha256=7gigfxFIFnDILi8BGQipuLl-Cr71pwi5vE72hbpLdmI,2850
-otdf_python/aesgcm.py,sha256=jQgVSEeKM6MJuH2tvlClXIzvg11a5O_GEY9Sh56CrxE,1947
-otdf_python/assertion_config.py,sha256=rw0SIB3xG-nAeb5r_liuxLphU4tcj-zlq8rVvXncX-Y,2317
-otdf_python/asym_crypto.py,sha256=EYkMNhZJP5khH0IvICTOG2bMg_TMvd6wXDu5zW0jpj4,7234
-otdf_python/auth_headers.py,sha256=onS-fXsIZN4l33yQS9VspPvoiAnfM2B0nNAVL_YIGZ0,987
-otdf_python/autoconfigure_utils.py,sha256=W5aJ0tC7HWfGb_1Mva_oxgduUzSpPoyDeaq0rPwgPAs,3689
-otdf_python/cli.py,sha256=icooiGgRh8H1IlP-_iO7paLB60IXUSaSacODABeqrS4,21165
-otdf_python/collection_store.py,sha256=sYL6VMFDBfHfCCLk14iybeC_qoUlpJFB0wOMt1bdwpY,1429
-otdf_python/collection_store_impl.py,sha256=3RqO3rvDCosajKpuls5DiO2_SWYsNQul9_9L7n-lQ68,758
-otdf_python/config.py,sha256=l1Ykg1gFUrFZTnd6bwMI6oi_clR5uCZ_Y1qH7QKtW90,2523
-otdf_python/connect_client.py,sha256=TpHpcU2t19pSqWn30cqzfM48nDG590BfNTlDPgUu054,45
-otdf_python/constants.py,sha256=ArVgY9OF2fkVM7dg0-9N3xs0xmKy0DWDUlVcO0_n9PQ,102
-otdf_python/crypto_utils.py,sha256=x0cEltQDVW8bxJ9L555KQKJU4_dI5Uw2h7j9oQGNT38,2933
-otdf_python/dpop.py,sha256=-76xjKz9Alf529StB_jQWhr-gCAOBkpssaSYQw2EH1A,2295
-otdf_python/ecc_constants.py,sha256=rCVZCWZ9zhyq2sqnUGFadiZ1CwXXe5T9olDtFYCJCIs,5846
-otdf_python/ecc_mode.py,sha256=aEAISAZpXcS72gXRUlYgH8n8EJP7zIpOeSVPxUJdAG8,3163
-otdf_python/ecdh.py,sha256=fwxE80qFSIkfJeUz3GNhEndRKkZrBN06FE1gnvwUHHI,10201
-otdf_python/eckeypair.py,sha256=qcPKv0OS1lYxRICj9dhAW_eMz32anFBtpI8EJfXxpX0,2470
-otdf_python/header.py,sha256=peG14kE_KAUCW4fY82sqcWF5zTAVAnJfFXCHtC8Z0iQ,7189
-otdf_python/invalid_zip_exception.py,sha256=M_bAiXEjJdxPfA178YH-uHGRwMrNBKzjQzlQ54aDP2w,292
-otdf_python/kas_allowlist.py,sha256=0yX3J9J1od_ew0sp3pX6kfav39pTz7aBBpMnVkE5T7s,5884
-otdf_python/kas_client.py,sha256=kcLpdkFDN3LVmlmSuaEm6EKtPsbOK5RCsClPdm8bpAU,27536
-otdf_python/kas_connect_rpc_client.py,sha256=Y2w0SPh4QZxLLhneKky8N20jd9UQmShmAnLo_c9kOXk,9113
-otdf_python/kas_info.py,sha256=R_zfW8m2n2PT1-Enk6NG5K8YIjWvb1g-PQ6M0bZX-o8,739
-otdf_python/kas_key_cache.py,sha256=6hfzRAg9o_IfRErWSe-_gGTG9kRyYENMizMY1Shkmfk,1548
-otdf_python/key_type.py,sha256=2gQlXOj35J3ISCcWjU3sGYUxmlZR47BMq6Xr2yoKA8k,928
-otdf_python/key_type_constants.py,sha256=0aqG1N1Ay0Z8o5fsq7fAiJXQeD6k-fxp06If__BGcR4,955
-otdf_python/manifest.py,sha256=aglGw9EdtZZIxmwqy82sV5wum_mKkjzew4brSgxmJjc,7047
-otdf_python/nanotdf.py,sha256=y1mLktlZ-mRCup2vzGY4ZbFeNEhWpCYLOZYjzTSPEtc,33921
-otdf_python/nanotdf_ecdsa_struct.py,sha256=C-qQnroJGO9yXrBb-p-rYMSxf2gS8kF6SCUvO-njAXU,4067
-otdf_python/nanotdf_type.py,sha256=3MQzT6lJ3WJKMICFyyYZXX2_cFYcZ5G4m1uif-l9Nxo,1112
-otdf_python/policy_binding_serializer.py,sha256=hA-M5BhEa3Q0bpjbpdiaJ6mivwx9UGDdmB8HvFG7SY0,1272
-otdf_python/policy_info.py,sha256=aq74dZg9PhTZ6cMkZyFsu3D754C5YijFMiuoYEL-1bY,2076
-otdf_python/policy_object.py,sha256=LikIsahPkKr-iYA0lhgQitCbh8CsmxUBYyBs6VYfmxY,512
-otdf_python/policy_stub.py,sha256=RfU_fICqsAOnTXOHpKhtKC0RJ3KoWhDxO0XecZWM548,159
-otdf_python/resource_locator.py,sha256=bjK935XcfNq-PyqidHNq8eIiPeZEStYdQvmQ9B9GY20,6290
-otdf_python/sdk.py,sha256=6yQbaHS6EUqiEOEn2hI3Ox4OYlYQHDuxjqHjYo8LV5A,15060
-otdf_python/sdk_builder.py,sha256=N57HrXADKLSP3bGiltYV058DxgrJyMzhsKuqNuKBqqo,17659
-otdf_python/sdk_exceptions.py,sha256=2GElGyM5LKN8Uh_lAiT6Ho4oNRWYRQsMNOK5s2jiv28,687
-otdf_python/symmetric_and_payload_config.py,sha256=iPHeZSeY9BjsQ-wkvdm6-FIR7773EgGiaIvSG-ICOHw,1158
-otdf_python/tdf.py,sha256=lqaSSGfd-nzlmjpYoXa6ZLihZIJA170dwodKt_iRko8,20799
-otdf_python/tdf_reader.py,sha256=f-LCb_Z4TwaByT8_gu-cpJIdW8lk3741jCAd-fJOLJg,5229
-otdf_python/tdf_writer.py,sha256=FLm1P26J4p6WPyKsjOb7QLYJqDIMDsBONqBW_JuFxyw,798
-otdf_python/token_source.py,sha256=Ow4bZqPqVxbZx64M7pLxQarVlPfiz15ZvZr9H17_ZMY,1021
-otdf_python/version.py,sha256=uDKJKsSQoaEH-JlqAwiXDxceLRX9hkG4I3NVLEfDCHA,2025
-otdf_python/zip_reader.py,sha256=qrHv-ecs09tz99ZKdOMiWaciYf2XsQOUTiXy1JHjuEY,1705
-otdf_python/zip_writer.py,sha256=5-KChgEXCf4TKAAML-R8cqpAiap85ur1l2lJCCac6BE,2405
 otdf_python_proto/__init__.py,sha256=dK3iYz7kos_DmjPzmboF1QkojrA0jFNFgmSEljgReR4,3211
 otdf_python_proto/authorization/__init__.py,sha256=PQ8pNK86JNhOg7rcvbOQzAx5nm0hdjQqj-xIwDD4izY,237
 otdf_python_proto/authorization/authorization_connect.py,sha256=sD5FEABMXq47ICNsdiwnAw9FjLHTvJAoZm4W4Q1VsIM,12521
@@ -170,6 +121,6 @@ otdf_python_proto/wellknownconfiguration/__init__.py,sha256=xK8XUrwCL9elWuMTx6vV
 otdf_python_proto/wellknownconfiguration/wellknown_configuration_connect.py,sha256=HShWKFfd_7p1aZzqZKJiT1lDma0IINTB4kfv_DcrBA0,6585
 otdf_python_proto/wellknownconfiguration/wellknown_configuration_pb2.py,sha256=KXjTE12hr8GV7apJLTzv2VDBv8jw-74jZUjQnIzzP8g,3633
 otdf_python_proto/wellknownconfiguration/wellknown_configuration_pb2.pyi,sha256=H-Pjnl-fvckhUilvIHIuuSbHTDovejk-e7HFQ8f8eOc,1431
-otdf_python-0.9.0.dist-info/METADATA,sha256=xMgKnS-QPDi9n1_gUCzGD-SNWmpRWntqqYM-cLMo7Rs,5037
-otdf_python-0.9.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-otdf_python-0.9.0.dist-info/RECORD,,
+otdf_python-0.10.0.dist-info/METADATA,sha256=m0riOnyyHG_L-PJJNk9_al1LS02RSJqQ9515TbkcpnU,5038
+otdf_python-0.10.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+otdf_python-0.10.0.dist-info/RECORD,,

{otdf_python-0.9.0.dist-info → otdf_python-0.10.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.30.1
+Generator: hatchling 1.31.0
 Root-Is-Purelib: true
 Tag: py3-none-any

otdf_python/__init__.py

@@ -1,24 +0,0 @@
-"""OpenTDF Python SDK.
-
-A Python implementation of the OpenTDF SDK for working with Trusted Data Format (TDF) files.
-Provides both programmatic APIs and command-line interface for encryption and decryption.
-"""
-
-from .cli import main as cli_main
-from .config import KASInfo, NanoTDFConfig, TDFConfig
-from .sdk import SDK
-from .sdk_builder import SDKBuilder
-
-__all__ = [
-    "SDK",
-    "KASInfo",
-    "NanoTDFConfig",
-    "SDKBuilder",
-    "TDFConfig",
-    "cli_main",
-]
-
-
-def main() -> None:
-    """Entry point for the CLI."""
-    cli_main()

otdf_python/__main__.py

@@ -1,11 +0,0 @@
-#!/usr/bin/env python3
-"""Main entry point for running otdf_python as a module.
-
-This allows the package to be run with `python -m otdf_python` and properly
-handles the CLI interface without import conflicts.
-"""
-
-from .cli import main
-
-if __name__ == "__main__":
-    main()

otdf_python/address_normalizer.py

@@ -1,82 +0,0 @@
-"""Address normalization utilities for OpenTDF."""
-
-import logging
-import re
-from urllib.parse import urlparse
-
-from .sdk_exceptions import SDKException
-
-logger = logging.getLogger(__name__)
-
-
-def normalize_address(url_string: str, use_plaintext: bool) -> str:
-    """Normalize a URL address to ensure it has the correct scheme and port.
-
-    Args:
-        url_string: The URL string to normalize
-        use_plaintext: If True, use http scheme, otherwise use https
-
-    Returns:
-        The normalized URL string
-
-    Raises:
-        SDKException: If there's an error parsing or creating the URL
-
-    """
-    scheme = "http" if use_plaintext else "https"
-
-    # Check if we have a host:port format without scheme (with non-digit port)
-    host_port_pattern = re.match(r"^([^/:]+):([^/]+)$", url_string)
-    if host_port_pattern:
-        host = host_port_pattern.group(1)
-        port_str = host_port_pattern.group(2)
-        try:
-            port = int(port_str)
-        except ValueError as err:
-            raise SDKException(f"Invalid port in URL [{url_string}]") from err
-
-        normalized_url = f"{scheme}://{host}:{port}"
-        logger.debug(f"normalized url [{url_string}] to [{normalized_url}]")
-        return normalized_url
-
-    try:
-        # Check if we just have a hostname without scheme and port
-        if "://" not in url_string and "/" not in url_string and ":" not in url_string:
-            port = 80 if use_plaintext else 443
-            normalized_url = f"{scheme}://{url_string}:{port}"
-            logger.debug(f"normalized url [{url_string}] to [{normalized_url}]")
-            return normalized_url
-
-        # Parse the URL
-        parsed_url = urlparse(url_string)
-
-        # If no scheme, add one
-        if not parsed_url.scheme:
-            url_string = f"{scheme}://{url_string}"
-            parsed_url = urlparse(url_string)
-
-        # Extract host and port
-        host = parsed_url.netloc.split(":")[0] if parsed_url.netloc else parsed_url.path
-
-        # If there's a port in the URL, try to extract it
-        port = None
-        if ":" in parsed_url.netloc:
-            _, port_str = parsed_url.netloc.split(":", 1)
-            try:
-                port = int(port_str)
-            except ValueError as err:
-                raise SDKException(f"Invalid port in URL [{url_string}]") from err
-
-        # If no port was found or extracted, use the default
-        if port is None:
-            port = 80 if use_plaintext else 443
-
-        # Reconstruct the URL with the desired scheme
-        normalized_url = f"{scheme}://{host}:{port}"
-        logger.debug(f"normalized url [{url_string}] to [{normalized_url}]")
-        return normalized_url
-
-    except Exception as e:
-        if isinstance(e, SDKException):
-            raise e
-        raise SDKException(f"Error normalizing URL [{url_string}]: {e}") from e

otdf_python/aesgcm.py

@@ -1,63 +0,0 @@
-"""AES-GCM encryption and decryption functionality."""
-
-import os
-
-from cryptography.hazmat.primitives.ciphers.aead import AESGCM
-
-
-class AesGcm:
-    """AES-GCM encryption and decryption operations."""
-
-    GCM_NONCE_LENGTH = 12
-    GCM_TAG_LENGTH = 16
-
-    def __init__(self, key: bytes):
-        """Initialize AES-GCM cipher with key."""
-        if not key or len(key) not in (16, 24, 32):
-            raise ValueError("Invalid key size for GCM encryption")
-        self.key = key
-        self.aesgcm = AESGCM(key)
-
-    def get_key(self) -> bytes:
-        return self.key
-
-    class Encrypted:
-        """Encrypted data with initialization vector and ciphertext."""
-
-        def __init__(self, iv: bytes, ciphertext: bytes):
-            """Initialize encrypted data."""
-            self.iv = iv
-            self.ciphertext = ciphertext
-
-        def as_bytes(self) -> bytes:
-            return self.iv + self.ciphertext
-
-    def encrypt(
-        self, plaintext: bytes, offset: int = 0, length: int | None = None
-    ) -> "AesGcm.Encrypted":
-        if length is None:
-            length = len(plaintext) - offset
-        iv = os.urandom(self.GCM_NONCE_LENGTH)
-        ct = self.aesgcm.encrypt(iv, plaintext[offset : offset + length], None)
-        return self.Encrypted(iv, ct)
-
-    def encrypt_with_iv(
-        self,
-        iv: bytes,
-        auth_tag_len: int,
-        plaintext: bytes,
-        offset: int = 0,
-        length: int | None = None,
-    ) -> bytes:
-        if length is None:
-            length = len(plaintext) - offset
-        ct = self.aesgcm.encrypt(iv, plaintext[offset : offset + length], None)
-        return iv + ct
-
-    def decrypt(self, encrypted: "AesGcm.Encrypted") -> bytes:
-        return self.aesgcm.decrypt(encrypted.iv, encrypted.ciphertext, None)
-
-    def decrypt_with_iv(
-        self, iv: bytes, auth_tag_len: int, cipher_data: bytes
-    ) -> bytes:
-        return self.aesgcm.decrypt(iv, cipher_data, None)

otdf_python/assertion_config.py

@@ -1,105 +0,0 @@
-"""Assertion configuration for TDF."""
-
-from enum import Enum, auto
-from typing import Any
-
-
-class Type(Enum):
-    """Assertion type enumeration."""
-
-    HANDLING_ASSERTION = "handling"
-    BASE_ASSERTION = "base"
-
-    def __str__(self):
-        return self.value
-
-
-class Scope(Enum):
-    """Assertion scope enumeration."""
-
-    TRUSTED_DATA_OBJ = "tdo"
-    PAYLOAD = "payload"
-
-    def __str__(self):
-        return self.value
-
-
-class AssertionKeyAlg(Enum):
-    """Assertion key algorithm enumeration."""
-
-    RS256 = auto()
-    HS256 = auto()
-    NOT_DEFINED = auto()
-
-
-class AppliesToState(Enum):
-    """Assertion applies-to state enumeration."""
-
-    ENCRYPTED = "encrypted"
-    UNENCRYPTED = "unencrypted"
-
-    def __str__(self):
-        return self.value
-
-
-class BindingMethod(Enum):
-    """Assertion binding method enumeration."""
-
-    JWS = "jws"
-
-    def __str__(self):
-        return self.value
-
-
-class AssertionKey:
-    """Assertion signing key configuration."""
-
-    def __init__(self, alg: AssertionKeyAlg, key: Any):
-        """Initialize assertion key."""
-        self.alg = alg
-        self.key = key
-
-    def is_defined(self):
-        return self.alg != AssertionKeyAlg.NOT_DEFINED
-
-
-class Statement:
-    """Assertion statement with format, schema, and value."""
-
-    def __init__(self, format: str, schema: str, value: str):
-        """Initialize assertion statement."""
-        self.format = format
-        self.schema = schema
-        self.value = value
-
-    def __eq__(self, other):
-        return (
-            isinstance(other, Statement)
-            and self.format == other.format
-            and self.schema == other.schema
-            and self.value == other.value
-        )
-
-    def __hash__(self):
-        return hash((self.format, self.schema, self.value))
-
-
-class AssertionConfig:
-    """TDF assertion configuration."""
-
-    def __init__(
-        self,
-        id: str,
-        type: Type,
-        scope: Scope,
-        applies_to_state: AppliesToState,
-        statement: Statement,
-        signing_key: AssertionKey | None = None,
-    ):
-        """Initialize assertion configuration."""
-        self.id = id
-        self.type = type
-        self.scope = scope
-        self.applies_to_state = applies_to_state
-        self.statement = statement
-        self.signing_key = signing_key

otdf_python/asym_crypto.py

@@ -1,194 +0,0 @@
-"""Asymmetric encryption and decryption utilities for RSA keys in PEM format."""
-
-import base64
-import re
-
-from cryptography.hazmat.backends import default_backend
-from cryptography.hazmat.primitives import hashes, serialization
-from cryptography.hazmat.primitives.asymmetric import padding, rsa
-from cryptography.x509 import load_pem_x509_certificate
-
-from .sdk_exceptions import SDKException
-
-
-class AsymDecryption:
-    """Provides functionality for asymmetric decryption using an RSA private key.
-
-    Supports both PEM string and key object initialization for flexibility.
-    """
-
-    CIPHER_TRANSFORM = "RSA/ECB/OAEPWithSHA-1AndMGF1Padding"
-    PRIVATE_KEY_HEADER = "-----BEGIN PRIVATE KEY-----"
-    PRIVATE_KEY_FOOTER = "-----END PRIVATE KEY-----"
-
-    def __init__(self, private_key_pem: str | None = None, private_key_obj=None):
-        """Initialize with either a PEM string or a key object.
-
-        Args:
-            private_key_pem: Private key in PEM format (with or without headers)
-            private_key_obj: Pre-loaded private key object from cryptography library
-
-        Raises:
-            SDKException: If key loading fails
-
-        """
-        if private_key_obj is not None:
-            self.private_key = private_key_obj
-        elif private_key_pem is not None:
-            try:
-                # Try direct PEM loading first (most common case)
-                try:
-                    self.private_key = serialization.load_pem_private_key(
-                        private_key_pem.encode(),
-                        password=None,
-                        backend=default_backend(),
-                    )
-                except Exception:
-                    # Fallback: strip headers and load as DER (for base64-only keys)
-                    private_key_pem = (
-                        private_key_pem.replace(self.PRIVATE_KEY_HEADER, "")
-                        .replace(self.PRIVATE_KEY_FOOTER, "")
-                        .replace("\n", "")
-                        .replace("\r", "")
-                        .replace(" ", "")
-                    )
-                    decoded = base64.b64decode(private_key_pem)
-                    self.private_key = serialization.load_der_private_key(
-                        decoded, password=None, backend=default_backend()
-                    )
-            except Exception as e:
-                raise SDKException(f"Failed to load private key: {e}") from e
-        else:
-            self.private_key = None
-
-    def decrypt(self, data: bytes) -> bytes:
-        """Decrypt data using RSA OAEP with SHA-1.
-
-        Args:
-            data: Encrypted bytes to decrypt
-
-        Returns:
-            Decrypted bytes
-
-        Raises:
-            SDKException: If decryption fails or key is not set
-
-        """
-        if self.private_key is None:
-            raise SDKException("Failed to decrypt, private key is empty")
-        try:
-            return self.private_key.decrypt(
-                data,
-                padding.OAEP(
-                    mgf=padding.MGF1(algorithm=hashes.SHA1()),
-                    algorithm=hashes.SHA1(),
-                    label=None,
-                ),
-            )
-        except Exception as e:
-            raise SDKException(f"Error performing decryption: {e}") from e
-
-
-class AsymEncryption:
-    """Provides functionality for asymmetric encryption using an RSA public key or certificate in PEM format.
-
-    Supports PEM public keys, X.509 certificates, and pre-loaded key objects.
-    Also handles base64-encoded keys without PEM headers.
-    """
-
-    PUBLIC_KEY_HEADER = "-----BEGIN PUBLIC KEY-----"
-    PUBLIC_KEY_FOOTER = "-----END PUBLIC KEY-----"
-    CIPHER_TRANSFORM = "RSA/ECB/OAEPWithSHA-1AndMGF1Padding"
-
-    def __init__(self, public_key_pem: str | None = None, public_key_obj=None):
-        """Initialize with either a PEM string or a key object.
-
-        Args:
-            public_key_pem: Public key in PEM format, X.509 certificate, or base64 string
-            public_key_obj: Pre-loaded public key object from cryptography library
-
-        Raises:
-            SDKException: If key loading fails or key is not RSA
-
-        """
-        if public_key_obj is not None:
-            self.public_key = public_key_obj
-        elif public_key_pem is not None:
-            try:
-                if "BEGIN CERTIFICATE" in public_key_pem:
-                    # Load from X.509 certificate
-                    cert = load_pem_x509_certificate(
-                        public_key_pem.encode(), default_backend()
-                    )
-                    self.public_key = cert.public_key()
-                else:
-                    # Try direct PEM loading first (most common case)
-                    try:
-                        self.public_key = serialization.load_pem_public_key(
-                            public_key_pem.encode(), backend=default_backend()
-                        )
-                    except Exception:
-                        # Fallback: strip headers and load as DER (for base64-only keys)
-                        pem_body = re.sub(r"-----BEGIN (.*)-----", "", public_key_pem)
-                        pem_body = re.sub(r"-----END (.*)-----", "", pem_body)
-                        pem_body = re.sub(r"\s", "", pem_body)
-                        decoded = base64.b64decode(pem_body)
-                        self.public_key = serialization.load_der_public_key(
-                            decoded, backend=default_backend()
-                        )
-            except Exception as e:
-                raise SDKException(f"Failed to load public key: {e}") from e
-        else:
-            self.public_key = None
-
-        # Validate that it's an RSA key
-        if self.public_key is not None and not isinstance(
-            self.public_key, rsa.RSAPublicKey
-        ):
-            raise SDKException("Not an RSA PEM formatted public key")
-
-    def encrypt(self, data: bytes) -> bytes:
-        """Encrypt data using RSA OAEP with SHA-1.
-
-        Args:
-            data: Plaintext bytes to encrypt
-
-        Returns:
-            Encrypted bytes
-
-        Raises:
-            SDKException: If encryption fails or key is not set
-
-        """
-        if self.public_key is None:
-            raise SDKException("Failed to encrypt, public key is empty")
-        try:
-            return self.public_key.encrypt(
-                data,
-                padding.OAEP(
-                    mgf=padding.MGF1(algorithm=hashes.SHA1()),
-                    algorithm=hashes.SHA1(),
-                    label=None,
-                ),
-            )
-        except Exception as e:
-            raise SDKException(f"Error performing encryption: {e}") from e
-
-    def public_key_in_pem_format(self) -> str:
-        """Export the public key to PEM format.
-
-        Returns:
-            Public key as PEM-encoded string
-
-        Raises:
-            SDKException: If export fails
-
-        """
-        try:
-            pem = self.public_key.public_bytes(
-                encoding=serialization.Encoding.PEM,
-                format=serialization.PublicFormat.SubjectPublicKeyInfo,
-            )
-            return pem.decode()
-        except Exception as e:
-            raise SDKException(f"Error exporting public key to PEM: {e}") from e

otdf_python/auth_headers.py

@@ -1,35 +0,0 @@
-"""Authentication header management."""
-
-from dataclasses import dataclass
-
-
-@dataclass
-class AuthHeaders:
-    """Represents authentication headers used in token-based authorization.
-
-    This class holds authorization and DPoP (Demonstrating Proof of Possession) headers
-    that are used in token-based API requests.
-    """
-
-    auth_header: str
-    dpop_header: str = ""
-
-    def get_auth_header(self) -> str:
-        """Get the authorization header."""
-        return self.auth_header
-
-    def get_dpop_header(self) -> str:
-        """Get the DPoP header."""
-        return self.dpop_header
-
-    def to_dict(self) -> dict[str, str]:
-        """Convert authentication headers to a dictionary for use with HTTP clients.
-
-        Returns:
-            Dictionary with 'Authorization' header and optionally 'DPoP' header
-
-        """
-        headers = {"Authorization": self.auth_header}
-        if self.dpop_header:
-            headers["DPoP"] = self.dpop_header
-        return headers