winiutils 2.3.12__py3-none-any.whl

winiutils/src/security/cryptography.py

@@ -0,0 +1,100 @@
+"""Cryptography utilities for secure data handling.
+
+This module provides utility functions for working with cryptography,
+including encryption and decryption using AES-GCM (Galois/Counter Mode).
+AES-GCM provides both confidentiality and authenticity guarantees.
+
+Example:
+    >>> from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+    >>> from winiutils.src.security.cryptography import (
+    ...     encrypt_with_aes_gcm,
+    ...     decrypt_with_aes_gcm,
+    ... )
+    >>> key = AESGCM.generate_key(bit_length=256)
+    >>> aes_gcm = AESGCM(key)
+    >>> encrypted = encrypt_with_aes_gcm(aes_gcm, b"secret message")
+    >>> decrypted = decrypt_with_aes_gcm(aes_gcm, encrypted)
+    >>> decrypted
+    b'secret message'
+"""
+
+import os
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+IV_LEN = 12
+"""int: Length of the initialization vector (IV) in bytes.
+
+AES-GCM requires a 12-byte (96-bit) IV for optimal performance and security.
+"""
+
+
+def encrypt_with_aes_gcm(
+    aes_gcm: AESGCM, data: bytes, aad: bytes | None = None
+) -> bytes:
+    """Encrypt data using AES-GCM with a random initialization vector.
+
+    Encrypts the provided data using AES-GCM and prepends a randomly
+    generated 12-byte IV to the ciphertext. The IV is required for
+    decryption.
+
+    Args:
+        aes_gcm: An initialized AESGCM cipher instance.
+        data: The plaintext data to encrypt.
+        aad: Optional additional authenticated data. This data is not
+            encrypted but is authenticated, meaning any tampering will
+            be detected during decryption.
+
+    Returns:
+        The encrypted data with the IV prepended. Format: ``IV + ciphertext``.
+
+    Example:
+        >>> key = AESGCM.generate_key(bit_length=256)
+        >>> aes_gcm = AESGCM(key)
+        >>> encrypted = encrypt_with_aes_gcm(aes_gcm, b"hello world")
+        >>> len(encrypted) > len(b"hello world")  # IV + ciphertext + tag
+        True
+
+    Note:
+        A new random IV is generated for each encryption call. Never reuse
+        an IV with the same key.
+    """
+    iv = os.urandom(IV_LEN)
+    encrypted = aes_gcm.encrypt(iv, data, aad)
+    return iv + encrypted
+
+
+def decrypt_with_aes_gcm(
+    aes_gcm: AESGCM, data: bytes, aad: bytes | None = None
+) -> bytes:
+    """Decrypt data that was encrypted with AES-GCM.
+
+    Extracts the IV from the beginning of the encrypted data and uses it
+    to decrypt the ciphertext. Also verifies the authentication tag to
+    ensure data integrity.
+
+    Args:
+        aes_gcm: An initialized AESGCM cipher instance with the same key
+            used for encryption.
+        data: The encrypted data with IV prepended (as returned by
+            ``encrypt_with_aes_gcm``).
+        aad: Optional additional authenticated data. Must match the AAD
+            used during encryption, or decryption will fail.
+
+    Returns:
+        The decrypted plaintext data.
+
+    Raises:
+        cryptography.exceptions.InvalidTag: If the authentication tag is
+            invalid, indicating the data was tampered with or the wrong
+            key/AAD was used.
+
+    Example:
+        >>> key = AESGCM.generate_key(bit_length=256)
+        >>> aes_gcm = AESGCM(key)
+        >>> encrypted = encrypt_with_aes_gcm(aes_gcm, b"secret")
+        >>> decrypt_with_aes_gcm(aes_gcm, encrypted)
+        b'secret'
+    """
+    iv, encrypted = data[:IV_LEN], data[IV_LEN:]
+    return aes_gcm.decrypt(iv, encrypted, aad)

winiutils/src/security/keyring.py

@@ -0,0 +1,167 @@
+"""Keyring utilities for secure storage and retrieval of secrets.
+
+This module provides utility functions for working with the OS keyring,
+including getting and creating cryptographic keys. Keys are stored
+securely in the system's credential manager (e.g., macOS Keychain,
+Windows Credential Manager, or Linux Secret Service).
+
+When running in GitHub Actions, a plaintext keyring is used instead
+since the system keyring is not available.
+
+Example:
+    >>> from winiutils.src.security.keyring import get_or_create_fernet
+    >>> fernet, key_bytes = get_or_create_fernet("my_app", "encryption_key")
+    >>> encrypted = fernet.encrypt(b"secret data")
+    >>> fernet.decrypt(encrypted)
+    b'secret data'
+"""
+
+from base64 import b64decode, b64encode
+from collections.abc import Callable
+
+import keyring
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from pyrig.src.git.git import running_in_github_actions
+
+if running_in_github_actions():
+    from keyrings.alt.file import PlaintextKeyring  # type: ignore[import-untyped]
+
+    keyring.set_keyring(PlaintextKeyring())
+
+
+def get_or_create_fernet(service_name: str, username: str) -> tuple[Fernet, bytes]:
+    """Get or create a Fernet symmetric encryption key from the keyring.
+
+    Retrieves an existing Fernet key from the system keyring, or generates
+    a new one if it doesn't exist. The key is stored in the keyring for
+    future use.
+
+    Args:
+        service_name: The service name to use for keyring storage. This
+            identifies your application.
+        username: The username/key identifier within the service.
+
+    Returns:
+        A tuple of (Fernet instance, raw key bytes). The Fernet instance
+        can be used directly for encryption/decryption.
+
+    Example:
+        >>> fernet, key = get_or_create_fernet("my_app", "main_key")
+        >>> encrypted = fernet.encrypt(b"hello")
+        >>> fernet.decrypt(encrypted)
+        b'hello'
+    """
+    return get_or_create_key(
+        service_name, username, Fernet, lambda: Fernet.generate_key()
+    )
+
+
+def get_or_create_aes_gcm(service_name: str, username: str) -> tuple[AESGCM, bytes]:
+    """Get or create an AES-GCM encryption key from the keyring.
+
+    Retrieves an existing AES-GCM key from the system keyring, or generates
+    a new 256-bit key if it doesn't exist. The key is stored in the keyring
+    for future use.
+
+    Args:
+        service_name: The service name to use for keyring storage. This
+            identifies your application.
+        username: The username/key identifier within the service.
+
+    Returns:
+        A tuple of (AESGCM instance, raw key bytes). The AESGCM instance
+        can be used with ``encrypt_with_aes_gcm`` and ``decrypt_with_aes_gcm``.
+
+    Example:
+        >>> aes_gcm, key = get_or_create_aes_gcm("my_app", "aes_key")
+        >>> from winiutils.src.security.cryptography import encrypt_with_aes_gcm
+        >>> encrypted = encrypt_with_aes_gcm(aes_gcm, b"secret")
+    """
+    return get_or_create_key(
+        service_name, username, AESGCM, lambda: AESGCM.generate_key(bit_length=256)
+    )
+
+
+def get_or_create_key[T](
+    service_name: str,
+    username: str,
+    key_class: Callable[[bytes], T],
+    generate_key_func: Callable[..., bytes],
+) -> tuple[T, bytes]:
+    """Get or create a cryptographic key from the keyring.
+
+    Generic function that retrieves an existing key from the system keyring,
+    or generates a new one using the provided generator function if it
+    doesn't exist.
+
+    Args:
+        service_name: The service name to use for keyring storage.
+        username: The username/key identifier within the service.
+        key_class: A callable that takes raw key bytes and returns a cipher
+            instance (e.g., ``Fernet``, ``AESGCM``).
+        generate_key_func: A callable that generates new raw key bytes.
+
+    Returns:
+        A tuple of (cipher instance, raw key bytes).
+
+    Note:
+        Keys are stored in the keyring as base64-encoded strings. The
+        service name is modified to include the key class name to allow
+        storing different key types for the same service/username.
+
+    Example:
+        >>> from cryptography.fernet import Fernet
+        >>> cipher, key = get_or_create_key(
+        ...     "my_app",
+        ...     "custom_key",
+        ...     Fernet,
+        ...     Fernet.generate_key,
+        ... )
+    """
+    key = get_key_as_str(service_name, username, key_class)
+    if key is None:
+        binary_key = generate_key_func()
+        key = b64encode(binary_key).decode("ascii")
+        modified_service_name = make_service_name(service_name, key_class)
+        keyring.set_password(modified_service_name, username, key)
+
+    binary_key = b64decode(key)
+    return key_class(binary_key), binary_key
+
+
+def get_key_as_str[T](
+    service_name: str, username: str, key_class: Callable[[bytes], T]
+) -> str | None:
+    """Retrieve a key from the keyring as a base64-encoded string.
+
+    Args:
+        service_name: The service name used for keyring storage.
+        username: The username/key identifier within the service.
+        key_class: The key class used to modify the service name.
+
+    Returns:
+        The base64-encoded key string, or None if the key doesn't exist.
+    """
+    service_name = make_service_name(service_name, key_class)
+    return keyring.get_password(service_name, username)
+
+
+def make_service_name[T](service_name: str, key_class: Callable[[bytes], T]) -> str:
+    """Create a unique service name by combining service name and key class.
+
+    This allows storing different key types (Fernet, AESGCM, etc.) for the
+    same service and username combination.
+
+    Args:
+        service_name: The base service name.
+        key_class: The key class whose name will be appended.
+
+    Returns:
+        A modified service name in the format ``{service_name}_{class_name}``.
+
+    Example:
+        >>> make_service_name("my_app", Fernet)
+        'my_app_Fernet'
+    """
+    return f"{service_name}_{key_class.__name__}"  # ty:ignore[unresolved-attribute]

winiutils-2.3.12.dist-info/METADATA

@@ -0,0 +1,283 @@
+Metadata-Version: 2.4
+Name: winiutils
+Version: 2.3.12
+Summary: A utility library for Python development
+Author: Winipedia
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: cryptography
+Requires-Dist: defusedxml
+Requires-Dist: keyring
+Requires-Dist: keyrings-alt
+Requires-Dist: polars
+Requires-Dist: pyrig
+Requires-Dist: tqdm
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# winiutils
+
+<!-- tooling -->
+[![pyrig](https://img.shields.io/badge/built%20with-pyrig-3776AB?logo=buildkite&logoColor=black)](https://github.com/Winipedia/pyrig)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://pre-commit.com/)
+<!-- code-quality -->
+[![ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![ty](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)[![mypy](https://img.shields.io/badge/type%20checked-mypy-039dfc.svg)](https://mypy-lang.org/)
+[![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
+[![pytest](https://img.shields.io/badge/tested%20with-pytest-46a2f1.svg?logo=pytest)](https://pytest.org/)
+[![codecov](https://codecov.io/gh/Winipedia/winiutils/branch/main/graph/badge.svg)](https://codecov.io/gh/Winipedia/winiutils)
+<!-- package-info -->
+[![PyPI](https://img.shields.io/pypi/v/winiutils?logo=pypi&logoColor=white)](https://pypi.org/project/winiutils/)
+[![Python](https://img.shields.io/badge/python-3.12|3.13|3.14-blue.svg?logo=python&logoColor=white)](https://www.python.org/)
+[![License](https://img.shields.io/github/license/Winipedia/winiutils)](https://github.com/Winipedia/winiutils/blob/main/LICENSE)
+<!-- ci/cd -->
+[![CI](https://img.shields.io/github/actions/workflow/status/Winipedia/winiutils/health_check.yaml?label=CI&logo=github)](https://github.com/Winipedia/winiutils/actions/workflows/health_check.yaml)
+[![CD](https://img.shields.io/github/actions/workflow/status/Winipedia/winiutils/release.yaml?label=CD&logo=github)](https://github.com/Winipedia/winiutils/actions/workflows/release.yaml)
+
+
+---
+
+> A utility library for Python development
+
+---
+
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Documentation](#documentation)
+- [Modules](#modules)
+- [Development](#development)
+- [License](#license)
+
+---
+
+## Features
+
+- **DataFrame Cleaning Pipeline** — Extensible Polars DataFrame cleaning with an 8-step pipeline
+- **Concurrent Processing** — Unified multiprocessing and multithreading with automatic resource optimization
+- **OOP Utilities** — Metaclasses and mixins for automatic method logging and instrumentation
+- **Security Tools** — OS keyring integration and AES-GCM encryption utilities
+- **Type Safety** — Full type hints with strict mypy compliance
+- **Production Ready** — Comprehensive test coverage and logging integration
+
+---
+
+## Installation
+
+### Using uv (recommended)
+
+```bash
+uv add winiutils
+```
+
+### Using pip
+
+```bash
+pip install winiutils
+```
+
+### From source
+
+```bash
+git clone https://github.com/Winipedia/winiutils.git
+cd winiutils
+uv sync
+```
+
+---
+
+## Quick Start
+
+### DataFrame Cleaning
+
+```python
+from winiutils.src.data.dataframe.cleaning import CleaningDF
+import polars as pl
+
+class UserDataCleaner(CleaningDF):
+    """Clean and standardize user data."""
+
+    USER_ID = "user_id"
+    EMAIL = "email"
+    SCORE = "score"
+
+    @classmethod
+    def get_rename_map(cls):
+        return {cls.USER_ID: "UserId", cls.EMAIL: "Email", cls.SCORE: "Score"}
+
+    @classmethod
+    def get_col_dtype_map(cls):
+        return {cls.USER_ID: pl.Int64, cls.EMAIL: pl.Utf8, cls.SCORE: pl.Float64}
+
+    # ... implement other abstract methods
+
+# Usage
+cleaned = UserDataCleaner(raw_dataframe)
+result = cleaned.df
+```
+
+### Concurrent Processing
+
+```python
+from winiutils.src.iterating.concurrent.multiprocessing import multiprocess_loop
+from winiutils.src.iterating.concurrent.multithreading import multithread_loop
+
+# CPU-bound tasks (multiprocessing)
+def process_chunk(data, config):
+    return heavy_computation(data, config)
+
+results = multiprocess_loop(
+    process_function=process_chunk,
+    process_args=[(chunk,) for chunk in data_chunks],
+    process_args_static=(config,),
+    process_args_len=len(data_chunks),
+)
+
+# I/O-bound tasks (multithreading)
+def fetch_url(url, headers):
+    return requests.get(url, headers=headers)
+
+results = multithread_loop(
+    process_function=fetch_url,
+    process_args=[(url,) for url in urls],
+    process_args_static=(headers,),
+    process_args_len=len(urls),
+)
+```
+
+### Automatic Method Logging
+
+```python
+from winiutils.src.oop.mixins.mixin import ABCLoggingMixin
+
+class MyService(ABCLoggingMixin):
+    def process_data(self, data: list) -> dict:
+        # Automatically logged with timing
+        return {"processed": len(data)}
+
+# Logs: "MyService - Calling process_data with (...) and {...}"
+# Logs: "MyService - process_data finished with 0.5 seconds -> returning {...}"
+```
+
+### Encryption with Keyring
+
+```python
+from winiutils.src.security.keyring import get_or_create_aes_gcm
+from winiutils.src.security.cryptography import encrypt_with_aes_gcm, decrypt_with_aes_gcm
+
+# Get or create encryption key (stored in OS keyring)
+aes_gcm, key = get_or_create_aes_gcm("my_app", "user@example.com")
+
+# Encrypt and decrypt
+encrypted = encrypt_with_aes_gcm(aes_gcm, b"Secret message")
+decrypted = decrypt_with_aes_gcm(aes_gcm, encrypted)
+```
+
+---
+
+## Documentation
+
+Full documentation is available in the [docs](./docs/) folder:
+
+- [**Data Processing**](./docs/data.md) — DataFrame cleaning pipeline and data structures
+- [**Iterating & Concurrency**](./docs/iterating.md) — Parallel processing utilities
+- [**OOP Utilities**](./docs/oop.md) — Metaclasses and mixins
+- [**Security**](./docs/security.md) — Encryption and keyring integration
+
+---
+
+## Modules
+
+| Module | Description |
+|--------|-------------|
+| [`winiutils.src.data`](./docs/data.md) | DataFrame cleaning pipeline and data structure utilities |
+| [`winiutils.src.iterating`](./docs/iterating.md) | Concurrent processing with multiprocessing and multithreading |
+| [`winiutils.src.oop`](./docs/oop.md) | Metaclasses and mixins for automatic method logging |
+| [`winiutils.src.security`](./docs/security.md) | AES-GCM encryption and OS keyring integration |
+
+---
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/Winipedia/winiutils.git
+cd winiutils
+uv sync --all-groups
+```
+
+### Running Tests
+
+```bash
+uv run pytest
+```
+
+### Code Quality
+
+```bash
+# Linting
+uv run ruff check .
+
+# Type checking
+uv run mypy .
+
+# Security scanning
+uv run bandit -r winiutils/
+```
+
+### Pre-commit Hooks
+
+```bash
+uv run pre-commit install
+uv run pre-commit run --all-files
+```
+
+---
+
+## Project Structure
+
+```
+winiutils/
+├── src/                          # Main source code
+│   ├── data/                     # Data processing
+│   │   ├── dataframe/            # Polars DataFrame cleaning
+│   │   └── structures/           # Dicts, text utilities
+│   ├── iterating/                # Iteration utilities
+│   │   └── concurrent/           # Multiprocessing & multithreading
+│   ├── oop/                      # OOP patterns
+│   │   └── mixins/               # Logging metaclass & mixin
+│   └── security/                 # Security utilities
+│       ├── cryptography.py       # AES-GCM encryption
+│       └── keyring.py            # OS keyring integration
+├── dev/                          # Development tools
+│   ├── cli/                      # CLI subcommands
+│   └── tests/fixtures/           # Test fixtures
+├── docs/                         # Documentation
+└── tests/                        # Test suite
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+---
+
+## Contributing
+
+Contributions are welcome! Please ensure:
+
+1. All tests pass (`uv run pytest`)
+2. Code passes linting (`uv run ruff check .`)
+3. Types are correct (`uv run mypy .`)
+4. New features include tests
+5. Documentation is updated for API changes

winiutils-2.3.12.dist-info/RECORD

@@ -0,0 +1,38 @@
+winiutils/__init__.py,sha256=vOWZ8n-YemVIzDLd8eWw1HVPGH3jxuT6VtDKHbmxk_A,43
+winiutils/dev/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winiutils/dev/builders/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winiutils/dev/cli/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winiutils/dev/cli/subcommands.py,sha256=iurWZwJwEKAfGpfjkn1YOhnRbIruCB4ouE-8R_Lh3JY,228
+winiutils/dev/configs/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winiutils/dev/tests/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winiutils/dev/tests/fixtures/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winiutils/dev/tests/fixtures/fixtures.py,sha256=oHJSjLS-oxS9r786S-wCCX5SQIbLt1rl2RjSLSW3S0A,937
+winiutils/main.py,sha256=TdxQpUtNZIiYCsEdysMlQW-1UNy0__WTax-Ot5E2eYQ,144
+winiutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+winiutils/resources/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winiutils/src/__init__.py,sha256=0-6q--PuFgSDe0_aXv_gih5f_2Q6kF9bmbT_RdpwNHA,86
+winiutils/src/data/__init__.py,sha256=hpYEUhFBe-IImSDT13GqYbo1ebL2j1i-s836fm0kBZY,262
+winiutils/src/data/dataframe/__init__.py,sha256=1oQTXgh9MR6ppUtLlcBxWSdyiu4AGYqZHHwaG8NQuu8,203
+winiutils/src/data/dataframe/cleaning.py,sha256=dfecVWVmcjw0LSxFuGmvDAHiv3wMjncujJHDtSOi_V0,27589
+winiutils/src/data/structures/__init__.py,sha256=zRTd-UHZLRH4LPSnQgKxNz2jcDT8Ah7x0gYfHxvKJEE,220
+winiutils/src/data/structures/dicts.py,sha256=8R6Jw47G-Z8ad63Hsj0UUaaH6eM-tCur36zKU5urYKY,1190
+winiutils/src/data/structures/text/__init__.py,sha256=8wUJOGa1-JLmdg0qaQzcuBOh99G2cyZvxO-T4qi9Ef0,195
+winiutils/src/data/structures/text/string.py,sha256=Heg_Y6CNQ3p1ZaQjuz1ffBu-Vd0UHp143AnLLL5dQE0,5379
+winiutils/src/iterating/__init__.py,sha256=25RIhD65SzjIkqRquxNHL8GMd3Cuvsw5EtG1ShYC64o,273
+winiutils/src/iterating/concurrent/__init__.py,sha256=ymePluCroEVm16NJV-r7tCUCWUZcp7jvfKYOlW7AWgM,373
+winiutils/src/iterating/concurrent/concurrent.py,sha256=EBvRuNG1XKubahZ405zX_j9c-iwwnS679GM03IP_cCQ,10717
+winiutils/src/iterating/concurrent/multiprocessing.py,sha256=bz8CNwUonvK8sej0Yo_pCdlJuBWwlRaKI2CX6Txiad4,6509
+winiutils/src/iterating/concurrent/multithreading.py,sha256=U3RN0vBdrbc8P059rP22yKE7umawjCbGlwN8CJd3TRg,4799
+winiutils/src/iterating/iterate.py,sha256=CQP8YfkYywAGFVlkib_KZtgTy57bt0oC1KKwdDlH4vU,1554
+winiutils/src/oop/__init__.py,sha256=HaR2nSm3P0Qj5iu9_8AtjDxeQS3fW17pZpgf2Yxyz80,232
+winiutils/src/oop/mixins/__init__.py,sha256=kjKziiB-AKThhy7uHqKznfh7otIqW_a3z1bf22VVP84,270
+winiutils/src/oop/mixins/meta.py,sha256=3hR5AGbqOPXumbytuDKRiW0VmBFuDENbrlwAjHCsdVg,7373
+winiutils/src/oop/mixins/mixin.py,sha256=1DBFhyHWtuYR4pAE8t85nfx9McxcM2YvwQKCTSFugOY,2109
+winiutils/src/security/__init__.py,sha256=6J6nWfzT2Xe2Yy7HHgj6dR2g9AYrqY77qL4aa_fzb94,250
+winiutils/src/security/cryptography.py,sha256=Oz-5LK4p43kjnriZGJzeUxfZmKyxN5CnbxVrSwsk8lQ,3424
+winiutils/src/security/keyring.py,sha256=PlEtJU2sJaM23IgLN1Tt93u3hNT_WsQiSw04TVfbuD8,6064
+winiutils-2.3.12.dist-info/licenses/LICENSE,sha256=o316mE2gGzd__JT69p7S_zlOmKiHh8YjpImCCcWyTvM,1066
+winiutils-2.3.12.dist-info/WHEEL,sha256=xDCZ-UyfvkGuEHPeI7BcJzYKIZzdqN8A8o1M5Om8IyA,79
+winiutils-2.3.12.dist-info/entry_points.txt,sha256=oH6bkIotdZXXBGdxsd3xv_7LBil4P0Ph4-L6PFySkTw,95
+winiutils-2.3.12.dist-info/METADATA,sha256=znX-DMTQHM9f2PifG0Tv1H9VNITAXT_QdlitorD7TXM,8670
+winiutils-2.3.12.dist-info/RECORD,,

winiutils-2.3.12.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.17
+Root-Is-Purelib: true
+Tag: py3-none-any

winiutils-2.3.12.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+winipedia-utils = pyrig.dev.cli.cli:main
+winiutils = pyrig.dev.cli.cli:main
+

winiutils-2.3.12.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Winipedia
+
+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.