nrtk-albumentations 2.1.0__py3-none-any.whl

albumentations/core/validation.py

@@ -0,0 +1,129 @@
+"""Module containing validation mechanisms for transform parameters.
+
+This module provides a metaclass that enables parameter validation for transforms using
+Pydantic models. It intercepts the initialization of transform classes to validate their
+parameters against schema definitions, raising appropriate errors for invalid values and
+providing type conversion capabilities. This validation layer helps prevent runtime errors
+by catching configuration issues at initialization time.
+"""
+
+from __future__ import annotations
+
+from inspect import Parameter, signature
+from typing import Any, Callable
+from warnings import warn
+
+from pydantic import BaseModel, ValidationError
+
+
+class ValidatedTransformMeta(type):
+    """Metaclass that validates transform parameters during instantiation.
+
+    This metaclass enables automatic validation of transform parameters using Pydantic models,
+    ensuring proper typing and constraints are enforced before object creation.
+
+    Args:
+        original_init (Callable[..., Any]): Original __init__ method of the class.
+        args (tuple[Any, ...]): Positional arguments passed to the __init__ method.
+        kwargs (dict[str, Any]): Keyword arguments passed to the __init__ method.
+
+    """
+
+    @staticmethod
+    def _process_init_parameters(
+        original_init: Callable[..., Any],
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+    ) -> tuple[dict[str, Any], list[str], bool]:
+        init_params = signature(original_init).parameters
+        param_names = list(init_params.keys())[1:]  # Exclude 'self'
+        full_kwargs: dict[str, Any] = dict(zip(param_names, args)) | kwargs
+
+        # Get strict value before validation
+        strict = full_kwargs.pop("strict", False)
+
+        # Add default values if not provided
+        for parameter_name, parameter in init_params.items():
+            if (
+                parameter_name != "self"
+                and parameter_name not in full_kwargs
+                and parameter.default is not Parameter.empty
+            ):
+                full_kwargs[parameter_name] = parameter.default
+
+        return full_kwargs, param_names, strict
+
+    @staticmethod
+    def _validate_parameters(
+        schema_cls: type[BaseModel],
+        full_kwargs: dict[str, Any],
+        param_names: list[str],
+        strict: bool,
+    ) -> dict[str, Any]:
+        try:
+            # Include strict parameter for schema validation
+            schema_kwargs = {k: v for k, v in full_kwargs.items() if k in param_names}
+            schema_kwargs["strict"] = strict
+            config = schema_cls(**schema_kwargs)
+            validated_kwargs = config.model_dump()
+            validated_kwargs.pop("strict", None)
+        except ValidationError as e:
+            raise ValueError(str(e)) from e
+        except Exception as e:
+            if strict:
+                raise ValueError(str(e)) from e
+            warn(str(e), stacklevel=2)
+            return {}
+        else:
+            return validated_kwargs
+
+    @staticmethod
+    def _get_default_values(init_params: dict[str, Parameter]) -> dict[str, Any]:
+        validated_kwargs = {}
+        for param_name, param in init_params.items():
+            if param_name in {"self", "strict"}:
+                continue
+            if param.default is not Parameter.empty:
+                validated_kwargs[param_name] = param.default
+        return validated_kwargs
+
+    def __new__(cls: type[Any], name: str, bases: tuple[type, ...], dct: dict[str, Any]) -> type[Any]:
+        """This is a custom metaclass that validates the parameters of the class during instantiation.
+        It is used to ensure that the parameters of the class are valid and that they are of the correct type.
+        """
+        if "InitSchema" in dct and issubclass(dct["InitSchema"], BaseModel):
+            original_init: Callable[..., Any] | None = dct.get("__init__")
+            if original_init is None:
+                msg = "__init__ not found in class definition"
+                raise ValueError(msg)
+
+            original_sig = signature(original_init)
+
+            def custom_init(self: Any, *args: Any, **kwargs: Any) -> None:
+                full_kwargs, param_names, strict = cls._process_init_parameters(original_init, args, kwargs)
+
+                validated_kwargs = cls._validate_parameters(
+                    dct["InitSchema"],
+                    full_kwargs,
+                    param_names,
+                    strict,
+                ) or cls._get_default_values(signature(original_init).parameters)
+
+                # Store and check invalid args
+                invalid_args = [name_arg for name_arg in kwargs if name_arg not in param_names and name_arg != "strict"]
+                original_init(self, **validated_kwargs)
+                self.invalid_args = invalid_args
+
+                if invalid_args:
+                    message = f"Argument(s) '{', '.join(invalid_args)}' are not valid for transform {name}"
+                    if strict:
+                        raise ValueError(message)
+                    warn(message, stacklevel=2)
+
+            # Preserve the original signature and docstring
+            custom_init.__signature__ = original_sig  # type: ignore[attr-defined]
+            custom_init.__doc__ = original_init.__doc__
+
+            dct["__init__"] = custom_init
+
+        return super().__new__(cls, name, bases, dct)

albumentations/pytorch/__init__.py

@@ -0,0 +1 @@
+from .transforms import *

albumentations/pytorch/transforms.py

@@ -0,0 +1,189 @@
+"""Module containing PyTorch-specific transforms for Albumentations.
+
+This module provides transforms that convert NumPy arrays to PyTorch tensors in
+the appropriate format. It handles both 2D image data and 3D volumetric data,
+ensuring that the tensor dimensions are correctly arranged according to PyTorch's
+expected format (channels first). These transforms are typically used as the final
+step in an augmentation pipeline before feeding data to a PyTorch model.
+"""
+
+from __future__ import annotations
+
+from typing import Any, overload
+
+import numpy as np
+import torch
+
+from albumentations.core.transforms_interface import BasicTransform
+from albumentations.core.type_definitions import (
+    MONO_CHANNEL_DIMENSIONS,
+    NUM_MULTI_CHANNEL_DIMENSIONS,
+    NUM_VOLUME_DIMENSIONS,
+    Targets,
+)
+
+__all__ = ["ToTensor3D", "ToTensorV2"]
+
+
+class ToTensorV2(BasicTransform):
+    """Converts images/masks to PyTorch Tensors, inheriting from BasicTransform.
+    For images:
+        - If input is in `HWC` format, converts to PyTorch `CHW` format
+        - If input is in `HW` format, converts to PyTorch `1HW` format (adds channel dimension)
+
+    Attributes:
+        transpose_mask (bool): If True, transposes 3D input mask dimensions from `[height, width, num_channels]` to
+            `[num_channels, height, width]`.
+        p (float): Probability of applying the transform. Default: 1.0.
+
+    """
+
+    _targets = (Targets.IMAGE, Targets.MASK)
+
+    def __init__(self, transpose_mask: bool = False, p: float = 1.0):
+        super().__init__(p=p)
+        self.transpose_mask = transpose_mask
+
+    @property
+    def targets(self) -> dict[str, Any]:
+        """Define mapping of target name to target function.
+
+        Returns:
+            dict[str, Any]: Dictionary mapping target names to corresponding transform functions.
+
+        """
+        return {
+            "image": self.apply,
+            "images": self.apply_to_images,
+            "mask": self.apply_to_mask,
+            "masks": self.apply_to_masks,
+        }
+
+    def apply(self, img: np.ndarray, **params: Any) -> torch.Tensor:
+        """Convert a 2D image array to a PyTorch tensor.
+
+        Converts image from HWC or HW format to CHW format, handling both
+        single-channel and multi-channel images.
+
+        Args:
+            img (np.ndarray): Image as a numpy array of shape (H,W) or (H,W,C)
+            **params (Any): Additional parameters
+
+        Returns:
+            torch.Tensor: PyTorch tensor in CHW format
+
+        Raises:
+            ValueError: If image dimensions are neither HW nor HWC
+
+        """
+        if img.ndim not in {MONO_CHANNEL_DIMENSIONS, NUM_MULTI_CHANNEL_DIMENSIONS}:
+            msg = "Albumentations only supports images in HW or HWC format"
+            raise ValueError(msg)
+
+        if img.ndim == MONO_CHANNEL_DIMENSIONS:
+            img = np.expand_dims(img, 2)
+
+        return torch.from_numpy(img.transpose(2, 0, 1))
+
+    def apply_to_mask(self, mask: np.ndarray, **params: Any) -> torch.Tensor:
+        """Convert a mask array to a PyTorch tensor.
+
+        If transpose_mask is True and mask has 3 dimensions (H,W,C),
+        converts mask to channels-first format (C,H,W).
+
+        Args:
+            mask (np.ndarray): Mask as a numpy array
+            **params (Any): Additional parameters
+
+        Returns:
+            torch.Tensor: PyTorch tensor of mask
+
+        """
+        if self.transpose_mask and mask.ndim == NUM_MULTI_CHANNEL_DIMENSIONS:
+            mask = mask.transpose(2, 0, 1)
+        return torch.from_numpy(mask)
+
+    @overload
+    def apply_to_masks(self, masks: list[np.ndarray], **params: Any) -> list[torch.Tensor]: ...
+
+    @overload
+    def apply_to_masks(self, masks: np.ndarray, **params: Any) -> torch.Tensor: ...
+
+    def apply_to_masks(self, masks: np.ndarray | list[np.ndarray], **params: Any) -> torch.Tensor | list[torch.Tensor]:
+        """Convert numpy array or list of numpy array masks to torch tensor(s).
+
+        Args:
+            masks (np.ndarray | list[np.ndarray]): Numpy array of shape (N, H, W) or (N, H, W, C),
+                or a list of numpy arrays with shape (H, W) or (H, W, C).
+            **params (Any): Additional parameters.
+
+        Returns:
+            torch.Tensor | list[torch.Tensor]: If transpose_mask is True and input is (N, H, W, C),
+                returns tensor of shape (N, C, H, W). If transpose_mask is True and input is (H, W, C), r
+                eturns a list of tensors with shape (C, H, W). Otherwise, returns tensors with the same shape as input.
+
+        """
+        if isinstance(masks, list):
+            return [self.apply_to_mask(mask, **params) for mask in masks]
+
+        if self.transpose_mask and masks.ndim == NUM_VOLUME_DIMENSIONS:  # (N, H, W, C)
+            masks = np.transpose(masks, (0, 3, 1, 2))  # -> (N, C, H, W)
+        return torch.from_numpy(masks)
+
+    def apply_to_images(self, images: np.ndarray, **params: Any) -> torch.Tensor:
+        """Convert batch of images from (N, H, W, C) to (N, C, H, W)."""
+        if images.ndim != NUM_VOLUME_DIMENSIONS:  # N,H,W,C
+            raise ValueError(f"Expected 4D array (N,H,W,C), got {images.ndim}D array")
+        return torch.from_numpy(images.transpose(0, 3, 1, 2))  # -> (N,C,H,W)
+
+
+class ToTensor3D(BasicTransform):
+    """Convert 3D volumes and masks to PyTorch tensors.
+
+    This transform is designed for 3D medical imaging data. It converts numpy arrays
+    to PyTorch tensors and ensures consistent channel positioning.
+
+    For all inputs (volumes and masks):
+        - Input:  (D, H, W, C) or (D, H, W) - depth, height, width, [channels]
+        - Output: (C, D, H, W) - channels first format for PyTorch
+                 For single-channel input, adds C=1 dimension
+
+    Note:
+        This transform always moves channels to first position as this is
+        the standard PyTorch format. For masks that need to stay in DHWC format,
+        use a different transform or handle the transposition after this transform.
+
+    Args:
+        p (float): Probability of applying the transform. Default: 1.0
+
+    """
+
+    _targets = (Targets.IMAGE, Targets.MASK)
+
+    def __init__(self, p: float = 1.0):
+        super().__init__(p=p)
+
+    @property
+    def targets(self) -> dict[str, Any]:
+        """Define mapping of target name to target function.
+
+        Returns:
+            dict[str, Any]: Dictionary mapping target names to corresponding transform functions
+
+        """
+        return {
+            "volume": self.apply_to_volume,
+            "mask3d": self.apply_to_mask3d,
+        }
+
+    def apply_to_volume(self, volume: np.ndarray, **params: Any) -> torch.Tensor:
+        """Convert 3D volume to channels-first tensor."""
+        if volume.ndim == NUM_VOLUME_DIMENSIONS:  # D,H,W,C
+            return torch.from_numpy(volume.transpose(3, 0, 1, 2))
+        if volume.ndim == NUM_VOLUME_DIMENSIONS - 1:  # D,H,W
+            return torch.from_numpy(volume[np.newaxis, ...])
+        raise ValueError(f"Expected 3D or 4D array (D,H,W) or (D,H,W,C), got {volume.ndim}D array")
+
+    def apply_to_mask3d(self, mask3d: np.ndarray, **params: Any) -> torch.Tensor:
+        """Convert 3D mask to channels-first tensor."""
+        return self.apply_to_volume(mask3d, **params)

nrtk_albumentations-2.1.0.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: nrtk-albumentations
+Version: 2.1.0
+Summary: Fork of Albumentations in direct support of NRTK (Natural Robustness Toolkit). Fast, flexible, and advanced augmentation library for deep learning, computer vision, and medical imaging. Offers a wide range of transformations for both 2D (images, masks, bboxes, keypoints) and 3D (volumes, volumetric masks, keypoints) data, with optimized performance and seamless integration into ML workflows.
+License: MIT
+License-File: LICENSE
+Keywords: 2D augmentation,3D augmentation,aerial photography,anomaly detection,artificial intelligence,autonomous driving,bounding boxes,classification,computer vision,computer vision library,data augmentation,data preprocessing,data science,deep learning,deep learning library,depth estimation,face recognition,fast augmentation,image augmentation,image processing,image transformation,images,instance segmentation,keras,keypoint detection,keypoints,machine learning,machine learning tools,masks,medical imaging,microscopy,object counting,object detection,optimized performance,panoptic segmentation,pose estimation,python library,pytorch,quality inspection,real-time processing,robotics vision,satellite imagery,semantic segmentation,tensorflow,volumes,volumetric data,volumetric masks
+Author: Vladimir Iglovikov
+Maintainer: Kitware, Inc.
+Maintainer-email: nrtk@kitware.com
+Requires-Python: >=3.9
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+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: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Provides-Extra: hub
+Provides-Extra: pytorch
+Provides-Extra: text
+Requires-Dist: PyYAML
+Requires-Dist: albucore (==0.0.28)
+Requires-Dist: eval-type-backport ; python_version < "3.10"
+Requires-Dist: numpy (>=1.24.4)
+Requires-Dist: opencv-python-headless (>=4.9.0.80)
+Requires-Dist: pydantic (>=2.9.2)
+Requires-Dist: scipy (>=1.10.0)
+Requires-Dist: typing-extensions (>=4.9.0) ; python_version < "3.10"
+Project-URL: Homepage, https://nrtk.readthedocs.io/
+Project-URL: Repository, https://github.com/Kitware/nrtk-albumentations
+Description-Content-Type: text/markdown
+
+# Albumentations (NRTK Fork)
+
+[![CI](https://github.com/Kitware/nrtk-albumentations/workflows/CI/badge.svg)](https://github.com/Kitware/nrtk-albumentations/actions)
+[![License: MIT](https://img.shields.io/badge/License-MIT-brightgreen.svg)](https://opensource.org/licenses/MIT)
+
+This is a fork of [Albumentations](https://github.com/albumentations-team/albumentations) maintained by Kitware in direct support of [NRTK (Natural Robustness Toolkit)](https://github.com/Kitware/nrtk).
+
+**Fork Information:**
+
+- Last upstream version: Albumentations v2.0.8
+- Forked: October 2025
+
+## About
+
+Albumentations is a Python library for fast and flexible image augmentation. This fork is maintained specifically for integration with NRTK and includes modifications to support NRTK's natural robustness evaluation workflows.
+
+Image augmentation is used in deep learning and computer vision tasks to increase the quality of trained models by creating new training samples from existing data through various transformations.
+
+## Key Features
+
+- **Complete Computer Vision Support**: Works with all major CV tasks including classification, segmentation (semantic & instance), object detection, and pose estimation
+- **Simple, Unified API**: One consistent interface for all data types - RGB/grayscale/multispectral images, masks, bounding boxes, and keypoints
+- **Rich Augmentation Library**: 70+ high-quality augmentations to enhance your training data
+- **Fast**: Optimized for production use with consistently high performance
+- **Deep Learning Integration**: Works with PyTorch, TensorFlow, and other frameworks
+- **3D Support**: Volumetric data transformations for medical imaging and other 3D applications
+
+## Installation
+
+This package is designed to be installed as a dependency of NRTK. For standalone installation, use:
+
+```bash
+pip install nrtk-albumentations
+```
+
+## A Simple Example
+
+This package is intended for use with NRTK's [AlbumentationPerturber](https://nrtk.readthedocs.io/en/latest/_implementations/nrtk.impls.perturb_image.generic.albumentations_perturber.AlbumentationsPerturber.html#albumentationsperturber). For direct usage:
+
+```python
+import albumentations as A
+import cv2
+
+# Declare an augmentation pipeline
+transform = A.Compose([
+    A.RandomCrop(width=256, height=256),
+    A.HorizontalFlip(p=0.5),
+    A.RandomBrightnessContrast(p=0.2),
+])
+
+# Read an image with OpenCV and convert it to the RGB colorspace
+image = cv2.imread("image.jpg")
+image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+# Augment an image
+transformed = transform(image=image)
+transformed_image = transformed["image"]
+```
+
+## Documentation
+
+For detailed documentation on available transforms and usage patterns, see:
+
+- [Albumentations (NRTK Fork) Documentation](https://nrtk-albumentations.readthedocs.io/)
+- [NRTK Documentation](https://nrtk.readthedocs.io/)
+
+## Available Transformations
+
+Albumentations provides 70+ transforms across several categories:
+
+### Pixel-level Transforms
+
+Transforms that modify pixel values without changing image geometry (masks, bboxes, keypoints remain unchanged):
+
+- Color adjustments: `RandomBrightnessContrast`, `HueSaturationValue`, `ColorJitter`
+- Noise addition: `GaussNoise`, `ISONoise`, `MultiplicativeNoise`
+- Blur effects: `GaussianBlur`, `MotionBlur`, `MedianBlur`, `Defocus`
+- Compression: `ImageCompression`
+- And many more...
+
+### Spatial-level Transforms
+
+Transforms that modify image geometry (automatically applied to masks, bboxes, keypoints):
+
+- Cropping: `RandomCrop`, `CenterCrop`, `RandomResizedCrop`
+- Flipping: `HorizontalFlip`, `VerticalFlip`
+- Rotation: `Rotate`, `RandomRotate90`, `SafeRotate`
+- Resizing: `Resize`, `LongestMaxSize`, `SmallestMaxSize`
+- Distortions: `ElasticTransform`, `GridDistortion`, `OpticalDistortion`
+- And many more...
+
+### 3D Transforms
+
+Transforms for volumetric data (medical imaging, etc.):
+
+- `RandomCrop3D`, `CenterCrop3D`
+- `Pad3D`, `PadIfNeeded3D`
+- `CoarseDropout3D`
+- `CubicSymmetry`
+
+For a complete list with detailed parameters, see the [transform reference](https://nrtk-albumentations.readthedocs.io/).
+
+## Maintainer
+
+**Kitware, Inc.** <nrtk@kitware.com>
+
+## Original Authors
+
+This library was originally created by:
+
+- Vladimir I. Iglovikov
+- Alexander Buslaev
+- Alex Parinov
+- Eugene Khvedchenya
+- Mikhail Druzhinin
+
+## Contributing
+
+This fork is maintained specifically for NRTK integration. We are not accepting general contributions at this time. For issues or questions related to NRTK integration, please open an issue on the [NRTK repository](https://github.com/Kitware/nrtk/issues).
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Citation
+
+If you use this library in your research, please consider citing the original Albumentations paper:
+
+```bibtex
+@Article{info11020125,
+    AUTHOR = {Buslaev, Alexander and Iglovikov, Vladimir I. and Khvedchenya, Eugene and Parinov, Alex and Druzhinin, Mikhail and Kalinin, Alexandr A.},
+    TITLE = {Albumentations: Fast and Flexible Image Augmentations},
+    JOURNAL = {Information},
+    VOLUME = {11},
+    YEAR = {2020},
+    NUMBER = {2},
+    ARTICLE-NUMBER = {125},
+    URL = {https://www.mdpi.com/2078-2489/11/2/125},
+    ISSN = {2078-2489},
+    DOI = {10.3390/info11020125}
+}
+```
+

nrtk_albumentations-2.1.0.dist-info/RECORD

@@ -0,0 +1,62 @@
+albumentations/__init__.py,sha256=Sk7dqtYmpts6J7IMOSKw4ujwnH_w5NUBzfzcztCkNcI,573
+albumentations/augmentations/__init__.py,sha256=qHQ0t3fYFf-qXQkKN7LyMnEaPzvIGajqJzh8K8NyGw4,782
+albumentations/augmentations/blur/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+albumentations/augmentations/blur/functional.py,sha256=bO5oiliKqL7p98YOe2Zl7ldD66zoxyTz2u7VexpQJBs,13776
+albumentations/augmentations/blur/transforms.py,sha256=12rI4oQSZymIex5WwncGhqs-YveDg844lBsq-77BU8s,64630
+albumentations/augmentations/crops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+albumentations/augmentations/crops/functional.py,sha256=bfrv8IhTjKXoow-dYeqEW5k4iX4GK2w1SrbqauW_22w,16903
+albumentations/augmentations/crops/transforms.py,sha256=m-6xXx7r1kM7v9yxhdnXybZ4jCJKZPswi0SJHL-k6NU,148240
+albumentations/augmentations/dropout/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+albumentations/augmentations/dropout/channel_dropout.py,sha256=xoIhL5rb6bKjBYGrzHhukSQ5PMUY9zECKClPFEvX8l0,5275
+albumentations/augmentations/dropout/coarse_dropout.py,sha256=4zD1J2aPnSbFB1OFm3Vao45VBYpWa90baYzU6vbPtwo,24492
+albumentations/augmentations/dropout/functional.py,sha256=Wpv4P6pQHN3rjbtUtiBq-7gcLuVnezQieGRbYCsD230,38362
+albumentations/augmentations/dropout/grid_dropout.py,sha256=jG4pa4ZbmSnwCKlxRBJi6QBO5gDO6zo4v5BoDkGeerU,7261
+albumentations/augmentations/dropout/mask_dropout.py,sha256=L6x2LPLbjq3CM_ZfXUcgG97AZH8bEL4mpX1PxA3Zx5w,10962
+albumentations/augmentations/dropout/transforms.py,sha256=8sZnobY574Y-z81OzYUf8ArWu4UvupNXbGa4UzjFo1g,18273
+albumentations/augmentations/dropout/xy_masking.py,sha256=_0L6aW752rCOP8ADvYWD4aJk7guAEVSZVbJYXTTBq4s,8097
+albumentations/augmentations/geometric/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+albumentations/augmentations/geometric/distortion.py,sha256=YQ5vkrNd4bZUrZDuKJFm6u9PIlfG3g8EYIPgYm-kISg,48045
+albumentations/augmentations/geometric/flip.py,sha256=2ZVlFhDSg6Mn8miMOtRemTy2u0G4De_8G7gsOrPjM9o,25203
+albumentations/augmentations/geometric/functional.py,sha256=PorxaiJJMDAH7Lms55AIttB4FIdOOHvq9ve6J0oI-h8,146597
+albumentations/augmentations/geometric/pad.py,sha256=JkuUslEFgYYmd-BA-Z0xYDhGbVYbUGZCybo4T1JOJtY,25372
+albumentations/augmentations/geometric/resize.py,sha256=7pOnGX6zzC-2kRgRBpCbBRzmtIciPCZTCag12G2sgKU,39492
+albumentations/augmentations/geometric/rotate.py,sha256=3I20GCBL65jWmBDkf4_qFFw9r33SuFdxxpddhRKrrFM,32685
+albumentations/augmentations/geometric/transforms.py,sha256=KcxMFVrCm0GcukS40QEnf1BsPP5Ga4Rk2CQCTJMaT0M,76125
+albumentations/augmentations/mixing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+albumentations/augmentations/mixing/domain_adaptation.py,sha256=AjT-awcV0tghUGf6Tey7McWGpYa15B0TAyDMQPHXJAs,34558
+albumentations/augmentations/mixing/domain_adaptation_functional.py,sha256=epgaxvSls0Edo3kMZ8Vdr_pmKShXjdX1SEq1sOF2qlw,18010
+albumentations/augmentations/mixing/functional.py,sha256=6VfJaGlGc95FBfAPF0atfGYMiAKJw0YGVXFS2NYdELA,34942
+albumentations/augmentations/mixing/transforms.py,sha256=q0mHPxZOF1C8uCEHPyzdpUw5kd7G5gCTOTQGor_Hv48,34380
+albumentations/augmentations/other/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+albumentations/augmentations/other/lambda_transform.py,sha256=Lvvv4shQCPlOR3Fjr46iuK-2vQTA4rNwJKxI9JhCk4c,6520
+albumentations/augmentations/other/type_transform.py,sha256=1PuYIAzufKmkim898xmgGQP9y8Lsir_EQXNxFJbBuww,9595
+albumentations/augmentations/pixel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+albumentations/augmentations/pixel/functional.py,sha256=-_ZuO3g2YkiBWmBHvKnFnVaXqJouO-OeB87u9u-TRZQ,141544
+albumentations/augmentations/pixel/transforms.py,sha256=Co0mqLYEHL9jG3n3TiFXf3Pl8N33yfLc7UWrxBHa0mE,291028
+albumentations/augmentations/spectrogram/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+albumentations/augmentations/spectrogram/transform.py,sha256=9EhuF4NlLS0DSJkTQ5EA2_1N3kEHXfrGf3GJj1qrkiw,7356
+albumentations/augmentations/text/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+albumentations/augmentations/text/functional.py,sha256=WOwNlwAlJH7Y33HWwaFiPezHn0TPcGgtOzW4b0BEQMo,10106
+albumentations/augmentations/text/transforms.py,sha256=Nco6PlvP0K5ErRlwHxAjRC88LdIe-HxtjTIEWeIp6bA,10991
+albumentations/augmentations/transforms3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+albumentations/augmentations/transforms3d/functional.py,sha256=McXenIxg2lXr19QxKX-BGpcZMkDS4r_CNf_MIkXKGmI,16163
+albumentations/augmentations/transforms3d/transforms.py,sha256=357bbh-D4qyJHoH_y7tDctFF1I8zyN966gD6jVHOZGk,56596
+albumentations/augmentations/utils.py,sha256=IWTwpDtc7fsMUj5PBPUuS-YUlay-WOTuvHLWqlEnVYU,9296
+albumentations/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+albumentations/core/bbox_utils.py,sha256=8ew3J42OhyFK1TimJMZbz2H165UUVkEF0EjzPd4xOp0,35659
+albumentations/core/composition.py,sha256=IzEEEdqQnEdNF4RdIsGAr6fs_4rIlXs6BT6W6Egp0_o,76503
+albumentations/core/hub_mixin.py,sha256=eQWqcb6f6GylX3kkQuXjn5b82K1wFebv-waEXsjU_oI,12479
+albumentations/core/keypoints_utils.py,sha256=4RvQcBH6i8kFNgaW7cCGUra8DUPUSBjeV3lWC10hCUg,19089
+albumentations/core/label_manager.py,sha256=1QQo3RexpnGwc3K0QHJ7RBVN9qG6XsWX-mwcNwZORAs,13082
+albumentations/core/pydantic.py,sha256=O-csH5n1h04gigOz0GxcZJAPSpGY2bzhrt10YU3jVHY,7645
+albumentations/core/serialization.py,sha256=yWcudkzgbRGrv7mbpgBfRQJlQBXZvrv4NzetnzC0BgI,14794
+albumentations/core/transforms_interface.py,sha256=gCfatqo_fSNkGI59kK6wBMZgZHZHf6Zp82uPkYjiAWc,37138
+albumentations/core/type_definitions.py,sha256=3d7Cpx78vGRuvcqygVF7BP8mOlDlg-9E4NH8d6JPyRE,3594
+albumentations/core/utils.py,sha256=CHVA47nW6C93JdXmO8k7_8D1uwJ30HNZN9LMOxBGDqY,20913
+albumentations/core/validation.py,sha256=PCfiqa-K-Jvu5NCcAp0r-NnDPnoBmJbUNeAoxFABPfk,5383
+albumentations/pytorch/__init__.py,sha256=_FX2n_Gzz9oGUCHqoQlo4ez2EBuXzhuDHDot-h2SCME,26
+albumentations/pytorch/transforms.py,sha256=PZ1MCraVEOdduxe6hykKzMITvHT02H3Ak76Ewpx-MRA,7237
+nrtk_albumentations-2.1.0.dist-info/METADATA,sha256=AqZdOV74fSNCe3-Q7qgGYDeMOCm99dKk3m7hjMFrgfg,8697
+nrtk_albumentations-2.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+nrtk_albumentations-2.1.0.dist-info/licenses/LICENSE,sha256=vqTcjpOuJ4S8zUXxzbpT2pe5lka8o5DH1yXhe3LcIYA,1114
+nrtk_albumentations-2.1.0.dist-info/RECORD,,

nrtk_albumentations-2.1.0.dist-info/WHEEL

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

nrtk_albumentations-2.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Vladimir Iglovikov, Alexander Buslaev, Alexander Parinov,
+
+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.