python-auth-toolkit 0.1.0__py3-none-any.whl

python_auth_toolkit/__init__.py

@@ -0,0 +1,19 @@
+"""
+python-auth-toolkit: A secure and configurable password and authentication toolkit.
+"""
+
+from python_auth_toolkit.password_hasher import PasswordHasher
+from python_auth_toolkit.password_validator import PasswordValidator
+from python_auth_toolkit.exceptions import (
+    AuthToolkitError,
+    UnsupportedAlgorithmError,
+    HashingError,
+)
+
+__all__ = [
+    "PasswordHasher",
+    "PasswordValidator",
+    "AuthToolkitError",
+    "UnsupportedAlgorithmError",
+    "HashingError",
+]

python_auth_toolkit/exceptions.py

@@ -0,0 +1,27 @@
+"""
+Custom exceptions for python-auth-toolkit.
+
+All exceptions inherit from AuthToolkitError for easy catch-all handling.
+"""
+class AuthToolkitError(Exception):
+    """Base exception for all python-auth-toolkit errors."""
+
+    def __init__(self, message: str = "An authentication toolkit error occurred."):
+        self.message = message
+        super().__init__(self.message)
+
+class UnsupportedAlgorithmError(AuthToolkitError):
+    """Raised when an unsupported hashing algorithm is requested."""
+
+    def __init__(self, algorithm: str = ""):
+        self.algorithm = algorithm
+        message = (
+            f"Unsupported algorithm: '{algorithm}'. Supported algorithms: 'bcrypt', 'argon2'."
+        )
+        super().__init__(message)
+
+class HashingError(AuthToolkitError):
+    """Raised when password hashing or verification fails unexpectedly."""
+
+    def __init__(self, message: str = "An error occurred during password hashing."):
+        super().__init__(message)

python_auth_toolkit/password_hasher.py

@@ -0,0 +1,201 @@
+import re
+
+import argon2
+import bcrypt
+
+from python_auth_toolkit.exceptions import ( UnsupportedAlgorithmError, HashingError )
+# Supported algorithms
+_SUPPORTED_ALGORITHMS = {"bcrypt", "argon2"}
+
+# Default cost parameters
+_DEFAULT_BCRYPT_ROUNDS = 12
+_DEFAULT_ARGON2_TIME_COST = 3
+_DEFAULT_ARGON2_MEMORY_COST = 65536  # 64 MiB
+_DEFAULT_ARGON2_PARALLELISM = 4
+
+class PasswordHasher:
+    """
+    Secure password hasher support Bcrypt and argon2.
+
+    Example:
+    hasher = PasswordHasher() #defaults to bycrpt, 12 rounds
+    hashed = hasher.hash("my_secure_password")
+
+    if hasher.varify("my_secure_password", hashed):
+        print("Password Matches!!!")
+
+    # chech if hash needs upgrading (e.g: after changing rounds)
+    if hasher.needs_rehash(hashed):
+        new_hash = hasher.hash("my_secure_password")
+
+    Args:
+        algorithm: Hashing algorithm to use. One of 'bcrypt' or 'argon2'.
+        rounds: Cost factor for bcrypt (4-31). Ignored for argon2.
+        time_cost: Time cost for argon2. Ignored for bcrypt.
+        memory_cost: Memory cost in KiB for argon2. Ignored for bcrypt.
+        parallelism: Parallelism factor for argon2. Ignored for bcrypt.
+    """
+
+    def __init__(
+            self,
+            algorithm: str = 'bcrypt',
+            rounds: int = _DEFAULT_BCRYPT_ROUNDS,
+            time_cost: int = _DEFAULT_ARGON2_TIME_COST,
+            memory_cost: int = _DEFAULT_ARGON2_MEMORY_COST,
+            parallelism: int = _DEFAULT_ARGON2_PARALLELISM,
+    ) -> None:
+        algorithm = algorithm.lower().strip()
+        if algorithm not in _SUPPORTED_ALGORITHMS:
+            raise UnsupportedAlgorithmError(algorithm)
+        
+        self.algorithm = algorithm
+        self.rounds = rounds
+        self.time_cost = time_cost
+        self.memory_cost = memory_cost
+        self.parallelism = parallelism
+
+    def hash(self, password: str) -> str:
+        """Hash a plaintext password with automatic salt generation.
+        
+        Args:
+            password: The plain text password to hash
+        
+        Returs:
+            The hashed password string (includes embedded salt and parameters)
+
+        Raises:
+            HashingError: If hashing fails unexpectedly.
+            ValueError: If password is empty.
+        """
+
+        if not password:
+            raise ValueError("Password cannot be empty.")
+        
+        try:
+            if self.algorithm == 'bcrypt':
+                return self._hash_bcrypt(password)
+            else:
+                return self._hash_argon2(password)
+        except (ValueError, TypeError) as e:
+            raise HashingError(f"Failed to hash password: {e}") from e
+        
+    def verify(self, password: str, hashed: str) -> bool:
+        """Verify plain text password against a stored hash.
+        Uses timing-safe comparision  internally (provided by bcrypt/agron2 libs)
+
+        Args:
+            password: The plain text password to verify.
+            hashed: The stored hash string is to verify against.
+        
+        Returns:
+            True if password matches the hash, else false.
+
+        Raises:
+            HashingError: If verification fails due to currupted hash.
+        """
+
+        if not password or not hashed:
+            return False
+        
+        try:
+            # Auto detect algorithm from hash format
+            if hashed.startswith("$argon2"):
+                return self._verify_argon2(password, hashed)
+            elif hashed.startswith("$2b$") or hashed.startswith("$2a$"):
+                return self._verify_bcrypt(password, hashed)
+            else:
+                raise HashingError(
+                    "Unrecognized hash format. Hash must start with '$2b$', '$2a$', or '$argon2'."
+                )
+        except HashingError:
+            raise
+        except Exception as e:
+            raise HashingError(f"Failed to verify password: {e}") from e
+        
+    def needs_rehash(self, hashed: str) -> bool:
+        """Check if a hash needs to be regenerated due to changed parameters.
+
+        This is useful when you upgrade your cost parameters — existing hashes
+        still verify correctly, but new hashes should use the updated params.
+
+        Args:
+            hashed: The stored hash string to check.
+
+        Returns:
+            True if the hash should be regenerated with current parameters.
+        """
+        if not hashed:
+            return True
+
+        try:
+            if hashed.startswith("$argon2"):
+                return self._needs_rehash_argon2(hashed)
+            elif hashed.startswith("$2b$") or hashed.startswith("$2a$"):
+                return self._needs_rehash_bcrypt(hashed)
+            else:
+                # Unknown format → definitely needs rehash
+                return True
+        except Exception:
+            return True
+
+    # ------------------------------------------------------------------
+    # Internal: bcrypt
+    # ------------------------------------------------------------------
+
+    def _hash_bcrypt(self, password: str) -> str:
+        """Hash with bcrypt. Salt is auto-generated."""
+        salt = bcrypt.gensalt(rounds=self.rounds)
+        hashed = bcrypt.hashpw(password.encode("utf-8"), salt)
+        return hashed.decode("utf-8")
+
+    def _verify_bcrypt(self, password: str, hashed: str) -> bool:
+        """Verify with bcrypt (timing-safe internally)."""
+        return bcrypt.checkpw(password.encode("utf-8"), hashed.encode("utf-8"))
+
+    def _needs_rehash_bcrypt(self, hashed: str) -> bool:
+        """Check if bcrypt hash uses different rounds than configured."""
+        # bcrypt hash format: $2b$<rounds>$<salt+hash>
+        match = re.match(r"\$2[ab]\$(\d+)\$", hashed)
+        if not match:
+            return True
+        stored_rounds = int(match.group(1))
+        return stored_rounds != self.rounds
+
+    @property
+    def _argon2_hasher(self) -> argon2.PasswordHasher:
+        """Lazily initialize the argon2 hasher instance."""
+        if not hasattr(self, "_argon2_hasher_instance"):
+            self._argon2_hasher_instance = argon2.PasswordHasher(
+                time_cost=self.time_cost,
+                memory_cost=self.memory_cost,
+                parallelism=self.parallelism,
+                type=argon2.Type.ID,
+            )
+        return self._argon2_hasher_instance
+
+    # ------------------------------------------------------------------
+    # Internal: argon2
+    # ------------------------------------------------------------------
+
+    def _hash_argon2(self, password: str) -> str:
+        """Hash with argon2id. Salt is auto-generated."""
+        return self._argon2_hasher.hash(password)
+
+    def _verify_argon2(self, password: str, hashed: str) -> bool:
+        """Verify with argon2 (timing-safe internally)."""
+        try:
+            return self._argon2_hasher.verify(hashed, password)
+        except argon2.exceptions.VerifyMismatchError:
+            return False
+
+    def _needs_rehash_argon2(self, hashed: str) -> bool:
+        """Check if argon2 hash uses different parameters than configured."""
+        return self._argon2_hasher.check_needs_rehash(hashed)
+
+    def __repr__(self) -> str:
+        if self.algorithm == "bcrypt":
+            return f"PasswordHasher(algorithm='bcrypt', rounds={self.rounds})"
+        return (
+            f"PasswordHasher(algorithm='argon2', time_cost={self.time_cost}, "
+            f"memory_cost={self.memory_cost}, parallelism={self.parallelism})"
+        )

python_auth_toolkit/password_validator.py

@@ -0,0 +1,356 @@
+from dataclasses import dataclass, field
+import re
+
+# Some Common passwords to block if block_common_passwords is True
+COMMON_PASSWORDS: frozenset[str] = frozenset(
+    {
+        "123456",
+        "password",
+        "12345678",
+        "qwerty",
+        "123456789",
+        "12345",
+        "1234",
+        "111111",
+        "1234567",
+        "dragon",
+        "123123",
+        "baseball",
+        "abc123",
+        "football",
+        "monkey",
+        "letmein",
+        "shadow",
+        "master",
+        "666666",
+        "qwertyuiop",
+        "123321",
+        "mustang",
+        "1234567890",
+        "michael",
+        "654321",
+        "superman",
+        "1qaz2wsx",
+        "7777777",
+        "121212",
+        "000000",
+        "qazwsx",
+        "123qwe",
+        "killer",
+        "trustno1",
+        "jordan",
+        "jennifer",
+        "zxcvbnm",
+        "asdfgh",
+        "hunter",
+        "buster",
+        "soccer",
+        "harley",
+        "batman",
+        "andrew",
+        "tigger",
+        "sunshine",
+        "iloveyou",
+        "2000",
+        "charlie",
+        "robert",
+        "thomas",
+        "hockey",
+        "ranger",
+        "daniel",
+        "starwars",
+        "klaster",
+        "112233",
+        "george",
+        "computer",
+        "michelle",
+        "jessica",
+        "pepper",
+        "1111",
+        "zxcvbn",
+        "555555",
+        "11111111",
+        "131313",
+        "freedom",
+        "777777",
+        "pass",
+        "maggie",
+        "159753",
+        "aaaaaa",
+        "ginger",
+        "princess",
+        "joshua",
+        "cheese",
+        "amanda",
+        "summer",
+        "love",
+        "ashley",
+        "nicole",
+        "chelsea",
+        "biteme",
+        "matthew",
+        "access",
+        "yankees",
+        "987654321",
+        "dallas",
+        "austin",
+        "thunder",
+        "taylor",
+        "matrix",
+        "mobilemail",
+        "william",
+        "corvette",
+        "hello",
+        "martin",
+        "heather",
+        "secret",
+        "merlin",
+        "diamond",
+        "1234qwer",
+        "gfhjkm",
+        "hammer",
+        "silver",
+        "222222",
+        "88888888",
+        "anthony",
+        "justin",
+        "test",
+        "bailey",
+        "q1w2e3r4t5",
+        "patrick",
+        "internet",
+        "scooter",
+        "orange",
+        "11111",
+        "golfer",
+        "cookie",
+        "richard",
+        "samantha",
+        "bigdog",
+        "guitar",
+        "jackson",
+        "whatever",
+        "mickey",
+        "chicken",
+        "sparky",
+        "snoopy",
+        "maverick",
+        "phoenix",
+        "camaro",
+        "peanut",
+        "morgan",
+        "welcome",
+        "falcon",
+        "cowboy",
+        "ferrari",
+        "samsung",
+        "andrea",
+        "smokey",
+        "steelers",
+        "joseph",
+        "mercedes",
+        "dakota",
+        "arsenal",
+        "eagles",
+        "melissa",
+        "boomer",
+        "booboo",
+        "spider",
+        "nascar",
+        "monster",
+        "tigers",
+        "yellow",
+        "xxxxxx",
+        "123123123",
+        "gateway",
+        "marina",
+        "diablo",
+        "bulldog",
+        "qwer1234",
+        "compaq",
+        "purple",
+        "hardcore",
+        "banana",
+        "junior",
+        "hannah",
+        "123654",
+        "lazarus",
+        "nicholas",
+        "swimming",
+        "trustme",
+        "dolphin",
+        "wildcats",
+        "adrian",
+        "alexis",
+        "password1",
+        "password123",
+        "admin",
+        "admin123",
+        "root",
+        "toor",
+        "pass123",
+        "changeme",
+        "welcome1",
+        "passw0rd",
+        "p@ssw0rd",
+        "p@ssword",
+        "qwerty123",
+        "letmein1",
+        "abc1234",
+        "welcome123",
+        "password1234",
+        "admin1234",
+    }
+)
+
+@dataclass
+class ValidationResult:
+    """Result of a password validation check.
+
+    Attributes:
+        is_valid: Whether the password passed all validation rules.
+        errors: List of human-readable error messages for failed rules.
+        strength_score: Password strength from 0 (very weak) to 100 (very strong).
+    """
+
+    is_valid: bool
+    errors: list[str] = field(default_factory=list)
+    strength_score: int = 0
+
+class PasswordValidator:
+    """
+    Configurable password strength validator.
+    Validates password against a set of configurable rules and provides an entropy score.
+
+    Example: 
+        validator = PasswordValidator(
+            min_length=8,
+            required_uppercase=1,
+            required_lowercase=1,
+            required_digits=1,
+            required_special=1)
+        result = validator.validate("P@ssw0rd")
+
+        if result.is_valid:
+            print("Password is valid with entropy:", result.entropy)
+        else:
+            print("Password is invalid. Errors:", result.errors)
+    """
+
+    def __init__(
+            self,
+            min_length: int = 8,
+            max_length: int = 128,
+            required_uppercase: bool = True,
+            required_lowercase: bool = True,
+            required_digits: bool = True,
+            required_special: bool = True,
+            block_common_passwords: bool = True,
+    ) -> None:
+        """
+        Initializes the PasswordValidator with configurable rules.
+        Args:
+            min_length (int): Minimum length of the password.
+            max_length (int): Maximum length of the password.
+            required_uppercase (bool): Whether at least one uppercase letter is required.
+            required_lowercase (bool): Whether at least one lowercase letter is required.
+            required_digits (bool): Whether at least one digit is required.
+            required_special (bool): Whether at least one special character is required.
+            block_common_passwords (bool): Whether to block common passwords.
+        """
+        if min_length < 1:
+            raise ValueError("Minimum length must be at least 1.")
+        if max_length < min_length:
+            raise ValueError("Maximum length must be greater than or equal to minimum length.")
+        
+        self.min_length = min_length
+        self.max_length = max_length    
+        self.required_uppercase = required_uppercase
+        self.required_lowercase = required_lowercase
+        self.required_digits = required_digits
+        self.required_special = required_special
+        self.block_common_passwords = block_common_passwords
+
+    def validate(self, password: str) -> ValidationResult:
+        """
+        Validate a password against all configurable rules.
+
+        Args:
+            password (str): The password to validate.
+
+        Returns:
+            ValidationResult: The result of the validation, including validity, errors, and strength score.
+        """
+        errors: list[str] = []
+
+        if len(password) < self.min_length:
+            errors.append(f"Password must be at least {self.min_length} characters long."
+                          f" Current length: {len(password)}.")
+        if len(password) > self.max_length:
+            errors.append(f"Password must be no more than {self.max_length} characters long."
+                          f" Current length: {len(password)}.")
+        
+        # Check for uppercase letters
+        if self.required_uppercase and not re.search(r"[A-Z]", password):
+            errors.append("Password must contain at least one uppercase letter.")
+        
+        # Check for lowercase letters
+        if self.required_lowercase and not re.search(r"[a-z]", password):
+            errors.append("Password must contain at least one lowercase letter.")
+
+        # Check for digits
+        if self.required_digits and not re.search(r"\d", password):
+            errors.append("Password must contain at least one digit.")
+
+        # Check for special characters
+        if self.required_special and not re.search(r"[!@#$%^&*()_+\-=\[\]{};':\"\\|,.<>\/?`~]", password):
+            errors.append("Password must contain at least one special character.")
+
+        # Check against common passwords
+        if self.block_common_passwords and password in COMMON_PASSWORDS:
+            errors.append("Password is too common and easily guessable.")
+
+        # Compute strength score
+        strength_score = self._calculate_strength(password)
+
+        return ValidationResult(
+            is_valid=len(errors) == 0,
+            errors=errors,
+            strength_score=strength_score
+        )
+        
+    def _calculate_strength(self, password: str) -> int:
+        """
+        Calculate a password strength score based on its characteristics.
+
+        Args:
+            password (str): The password to evaluate.
+
+        Returns:
+            int: Strength score from 0 (very weak) to 100 (very strong).
+        """
+        score = 0
+
+        if not password:
+            return 0
+        
+        # Length contributes up to 40 points
+        if len(password) >= self.min_length:
+            score += min(40, (len(password) - self.min_length) * 4)
+
+        # Character variety contributes up to 30 points
+        if re.search(r"[A-Z]", password):
+            score += 10
+        if re.search(r"[a-z]", password):
+            score += 10
+        if re.search(r"\d", password):
+            score += 10
+        if re.search(r"[!@#$%^&*()_+\-=\[\]{};':\"\\|,.<>\/?`~]", password):
+            score += 10
+
+        # Deduct points for common passwords
+        if self.block_common_passwords and password in COMMON_PASSWORDS:
+            score -= 20
+
+        return max(0, min(100, score))
+

python_auth_toolkit/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561.

python_auth_toolkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: python-auth-toolkit
+Version: 0.1.0
+Summary: All-in-one Python authentication toolkit: password validation, password hashing, email validation.
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bcrypt>=4.0
+Requires-Dist: argon2-cffi>=21.3
+Requires-Dist: email-validator>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: license-file
+
+# python-auth-toolkit
+
+[![PyPI version](https://img.shields.io/pypi/v/python-auth-toolkit.svg)](https://pypi.org/project/python-auth-toolkit/)
+[![Python versions](https://img.shields.io/pypi/pyversions/python-auth-toolkit.svg)](https://pypi.org/project/python-auth-toolkit/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+An all-in-one, highly secure, and configurable Python authentication toolkit. It provides robust password strength validation, secure password hashing (Bcrypt & Argon2), and custom validation error feedback.
+
+---
+
+## Features
+
+- **Password Validator**: Fully customizable rules (minimum/maximum length, uppercase/lowercase requirements, digit requirements, and special character requirements).
+- **Common Passwords Protection**: Built-in protection to block the most common easily guessable passwords (e.g., "123456", "password", "qwerty").
+- **Password Hasher**: Secure password hashing supporting **Bcrypt** and **Argon2id** with timing-safe verification.
+- **Upgrades & Re-hashing**: Easy checking for out-of-date password hashes (e.g., when cost factors are increased) to allow seamless re-hashing.
+- **Type Safety**: Full PEP 561 type annotation support.
+
+---
+
+## Installation
+
+Install using `pip`:
+
+```bash
+pip install python-auth-toolkit
+```
+
+---
+
+## Quick Start
+
+### 1. Password Hashing
+
+```python
+from python_auth_toolkit import PasswordHasher
+
+# Initialize with default settings (Bcrypt with 12 rounds)
+hasher = PasswordHasher()
+
+# Hash a password
+hashed = hasher.hash("my_secure_password")
+print(hashed)  # Output: $2b$12$... (embedded salt and rounds)
+
+# Verify a password
+is_match = hasher.verify("my_secure_password", hashed)
+print(is_match)  # True
+
+# Check if a hash needs to be regenerated (e.g., after increasing security defaults)
+upgraded_hasher = PasswordHasher(rounds=14)
+if upgraded_hasher.needs_rehash(hashed):
+    new_hash = upgraded_hasher.hash("my_secure_password")
+```
+
+Using **Argon2**:
+
+```python
+from python_auth_toolkit import PasswordHasher
+
+# Initialize with Argon2id
+hasher = PasswordHasher(algorithm="argon2", time_cost=3, memory_cost=65536)
+
+# Hash and verify
+hashed = hasher.hash("another_password")
+is_match = hasher.verify("another_password", hashed)
+```
+
+### 2. Password Strength Validation
+
+```python
+from python_auth_toolkit import PasswordValidator
+
+# Initialize validator with custom rules
+validator = PasswordValidator(
+    min_length=10,
+    required_uppercase=True,
+    required_lowercase=True,
+    required_digits=True,
+    required_special=True,
+    block_common_passwords=True
+)
+
+# Validate a password
+result = validator.validate("P@ssw0rd123")
+
+if result.is_valid:
+    print(f"Valid! Strength Score: {result.strength_score}/100")
+else:
+    print("Invalid Password. Errors:")
+    for error in result.errors:
+        print(f" - {error}")
+```
+
+---
+
+## Configuration Options
+
+### `PasswordValidator` parameters:
+- `min_length` (int, default: 8): Minimum length required.
+- `max_length` (int, default: 128): Maximum length allowed.
+- `required_uppercase` (bool, default: True): Require at least one uppercase letter.
+- `required_lowercase` (bool, default: True): Require at least one lowercase letter.
+- `required_digits` (bool, default: True): Require at least one digit.
+- `required_special` (bool, default: True): Require at least one special character.
+- `block_common_passwords` (bool, default: True): Reject passwords present in the common passwords list.
+
+### `PasswordHasher` parameters:
+- `algorithm` (str, default: 'bcrypt'): Choose between `'bcrypt'` or `'argon2'`.
+- `rounds` (int, default: 12): Cost factor rounds for Bcrypt.
+- `time_cost` (int, default: 3): Time cost for Argon2.
+- `memory_cost` (int, default: 65536): Memory cost in KiB for Argon2.
+- `parallelism` (int, default: 4): Parallelism factor threads for Argon2.
+
+---
+
+## Requirements
+
+- Python >= 3.9
+- bcrypt >= 4.0
+- argon2-cffi >= 21.3
+- email-validator >= 2.0
+
+---
+
+## License
+
+This project is licensed under the MIT License. See the `LICENSE` file for details.

python_auth_toolkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+python_auth_toolkit/__init__.py,sha256=P0yxDmQ8N1AL3GFKfXNTYsbFf1tZeln5rIown2hcNMA,482
+python_auth_toolkit/exceptions.py,sha256=9v-33wCXmX1ks4Cp24o_Y84jdfIQsYVcUAbyCGmEJGc,997
+python_auth_toolkit/password_hasher.py,sha256=dHd7IuOHStwqvH9D1mG9qMQDyYL78N1OTncQB31vG_o,7630
+python_auth_toolkit/password_validator.py,sha256=dJaSUyGn6u6mmkBChRBkLjZgSxX7-QU6aYREaXQrpfA,9919
+python_auth_toolkit/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
+python_auth_toolkit-0.1.0.dist-info/licenses/LICENSE,sha256=ESYyLizI0WWtxMeS7rGVcX3ivMezm-HOd5WdeOh-9oU,1056
+python_auth_toolkit-0.1.0.dist-info/METADATA,sha256=Lb6RnVL_nBnlximsWK5wVcH1UYSPiFvQ0VZwijge904,5291
+python_auth_toolkit-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_auth_toolkit-0.1.0.dist-info/top_level.txt,sha256=_dmUHQy6a111OC6iVloDJsQxVDm2NdXDGFAzhcQynGA,20
+python_auth_toolkit-0.1.0.dist-info/RECORD,,

python_auth_toolkit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_auth_toolkit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_auth_toolkit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+python_auth_toolkit