async-tiff 0.5.0b2__cp311-abi3-musllinux_1_2_x86_64.whl

async_tiff/__init__.py

@@ -0,0 +1,31 @@
+from . import enums, store
+from ._async_tiff import (
+    TIFF,
+    Array,
+    Colormap,
+    DecoderRegistry,
+    GeoKeyDirectory,
+    ImageFileDirectory,
+    ThreadPool,
+    Tile,
+    ___version,  # noqa: F403 # pyright:ignore[reportAttributeAccessIssue]
+)
+from ._decoder_runtime import Decoder
+from ._input import ObspecInput
+
+__version__: str = ___version()
+
+__all__ = [
+    "enums",
+    "store",
+    "Array",
+    "Colormap",
+    "Decoder",
+    "DecoderRegistry",
+    "GeoKeyDirectory",
+    "ImageFileDirectory",
+    "ThreadPool",
+    "TIFF",
+    "ObspecInput",
+    "Tile",
+]

async_tiff/_array.pyi

@@ -0,0 +1,45 @@
+import sys
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+else:
+    from typing_extensions import Buffer
+
+class Array(Buffer):
+    """A 3D array that implements Python's buffer protocol.
+
+    This allows zero-copy interoperability with numpy via `np.asarray(arr)`.
+    The array is immutable and exposes a read-only buffer.
+
+    Example:
+
+    ```python
+    import numpy as np
+    from async_tiff import Array
+
+    # Create from raw bytes
+    data = bytes([1, 2, 3, 4, 5, 6])
+    arr = Array(data, shape=(1, 2, 3), format="<B")  # 1x2x3 uint8 array
+
+    # Convert to numpy (zero-copy view)
+    np_arr = np.asarray(arr)
+    assert np_arr.shape == (1, 2, 3)
+    assert np_arr.dtype == np.uint8
+    ```
+    """
+
+    # This is intended only for tests
+    # def __init__(
+    #     self, data: Buffer, shape: tuple[int, int, int], format: str
+    # ) -> None: ...
+    def __buffer__(self, flags: int) -> memoryview[int]: ...
+    @property
+    def shape(self) -> tuple[int, int, int]:
+        """The shape of the array.
+
+        The interpretation depends on the PlanarConfiguration:
+
+        - PlanarConfiguration=1 (chunky): (height, width, bands)
+        - PlanarConfiguration=2 (planar): (bands, height, width)
+        """
+        ...

async_tiff/_async_tiff.pyi

@@ -0,0 +1,19 @@
+from ._array import Array
+from ._colormap import Colormap
+from ._decoder import DecoderRegistry
+from ._geo import GeoKeyDirectory
+from ._ifd import ImageFileDirectory
+from ._thread_pool import ThreadPool
+from ._tiff import TIFF
+from ._tile import Tile
+
+__all__ = [
+    "Array",
+    "Colormap",
+    "DecoderRegistry",
+    "GeoKeyDirectory",
+    "ImageFileDirectory",
+    "ThreadPool",
+    "TIFF",
+    "Tile",
+]

async_tiff/_colormap.pyi

@@ -0,0 +1,14 @@
+import sys
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+else:
+    from typing_extensions import Buffer
+
+class Colormap(Buffer):
+    """A 1D array of u16 values representing a TIFF colormap.
+
+    Implements Python's buffer protocol for zero-copy access via `np.asarray()`.
+    """
+    def __buffer__(self, flags: int) -> memoryview[int]: ...
+    def __len__(self) -> int: ...

async_tiff/_decoder.pyi

@@ -0,0 +1,19 @@
+from ._decoder_runtime import Decoder
+from .enums import Compression
+
+class DecoderRegistry:
+    """A registry holding multiple decoder methods."""
+    def __init__(
+        self, custom_decoders: dict[Compression | int, Decoder] | None = None
+    ) -> None:
+        """Construct a new decoder registry.
+
+        By default, pure-Rust decoders will be used for any recognized and supported
+        compression types. Only the supplied decoders will override Rust-native
+        decoders.
+
+        Args:
+            custom_decoders: any custom decoder methods to use. This will be applied
+                _after_ (and override) any default provided Rust decoders. Defaults to
+                None.
+        """

async_tiff/_decoder_runtime.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    if sys.version_info >= (3, 12):
+        from collections.abc import Buffer
+    else:
+        from typing_extensions import Buffer
+
+
+class Decoder(Protocol):
+    """A custom Python-provided decompression algorithm."""
+
+    # In the future, we could pass in photometric interpretation and jpeg tables as
+    # well.
+    @staticmethod
+    def __call__(buffer: Buffer) -> Buffer:
+        """A callback to decode compressed data."""
+        ...

async_tiff/_geo.pyi

@@ -0,0 +1,102 @@
+from collections.abc import Iterable
+from typing import Any
+
+class GeoKeyDirectory:
+    def keys(self) -> list[str]:
+        """A list of string keys representing the GeoKey fields."""
+    def __eq__(self, value: object) -> bool: ...
+    def __iter__(self) -> Iterable[str]:
+        """An iterable of string keys representing the GeoKey fields."""
+    def __getitem__(self, key: str) -> Any:
+        """Access GeoKey fields by string key."""
+
+    @property
+    def model_type(self) -> int | None: ...
+    @property
+    def raster_type(self) -> int | None: ...
+    @property
+    def citation(self) -> str | None: ...
+    @property
+    def geographic_type(self) -> int | None: ...
+    @property
+    def geog_citation(self) -> str | None: ...
+    @property
+    def geog_geodetic_datum(self) -> int | None: ...
+    @property
+    def geog_prime_meridian(self) -> int | None: ...
+    @property
+    def geog_linear_units(self) -> int | None: ...
+    @property
+    def geog_linear_unit_size(self) -> float | None: ...
+    @property
+    def geog_angular_units(self) -> int | None: ...
+    @property
+    def geog_angular_unit_size(self) -> float | None: ...
+    @property
+    def geog_ellipsoid(self) -> int | None: ...
+    @property
+    def geog_semi_major_axis(self) -> float | None: ...
+    @property
+    def geog_semi_minor_axis(self) -> float | None: ...
+    @property
+    def geog_inv_flattening(self) -> float | None: ...
+    @property
+    def geog_azimuth_units(self) -> int | None: ...
+    @property
+    def geog_prime_meridian_long(self) -> float | None: ...
+    @property
+    def projected_type(self) -> int | None: ...
+    @property
+    def proj_citation(self) -> str | None: ...
+    @property
+    def projection(self) -> int | None: ...
+    @property
+    def proj_coord_trans(self) -> int | None: ...
+    @property
+    def proj_linear_units(self) -> int | None: ...
+    @property
+    def proj_linear_unit_size(self) -> float | None: ...
+    @property
+    def proj_std_parallel1(self) -> float | None: ...
+    @property
+    def proj_std_parallel2(self) -> float | None: ...
+    @property
+    def proj_nat_origin_long(self) -> float | None: ...
+    @property
+    def proj_nat_origin_lat(self) -> float | None: ...
+    @property
+    def proj_false_easting(self) -> float | None: ...
+    @property
+    def proj_false_northing(self) -> float | None: ...
+    @property
+    def proj_false_origin_long(self) -> float | None: ...
+    @property
+    def proj_false_origin_lat(self) -> float | None: ...
+    @property
+    def proj_false_origin_easting(self) -> float | None: ...
+    @property
+    def proj_false_origin_northing(self) -> float | None: ...
+    @property
+    def proj_center_long(self) -> float | None: ...
+    @property
+    def proj_center_lat(self) -> float | None: ...
+    @property
+    def proj_center_easting(self) -> float | None: ...
+    @property
+    def proj_center_northing(self) -> float | None: ...
+    @property
+    def proj_scale_at_nat_origin(self) -> float | None: ...
+    @property
+    def proj_scale_at_center(self) -> float | None: ...
+    @property
+    def proj_azimuth_angle(self) -> float | None: ...
+    @property
+    def proj_straight_vert_pole_long(self) -> float | None: ...
+    @property
+    def vertical(self) -> int | None: ...
+    @property
+    def vertical_citation(self) -> str | None: ...
+    @property
+    def vertical_datum(self) -> int | None: ...
+    @property
+    def vertical_units(self) -> int | None: ...

async_tiff/_ifd.pyi

@@ -0,0 +1,150 @@
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+from ._colormap import Colormap
+from ._geo import GeoKeyDirectory
+from ._tile import Tile
+from .enums import (
+    Compression,
+    PhotometricInterpretation,
+    PlanarConfiguration,
+    Predictor,
+    ResolutionUnit,
+    SampleFormat,
+)
+
+Value = int | float | str | tuple[int, int] | list[Value]
+
+class ImageFileDirectory:
+    def keys(self) -> list[str]:
+        """A list of string keys representing the IFD fields."""
+    def __eq__(self, value: object) -> bool: ...
+    def __iter__(self) -> Iterable[str]:
+        """An iterable of string keys representing the IFD fields."""
+    def __getitem__(self, key: str) -> Any:
+        """Access IFD fields by string key."""
+
+    @property
+    def new_subfile_type(self) -> int | None: ...
+    @property
+    def image_width(self) -> int:
+        """The number of columns in the image, i.e., the number of pixels per row."""
+
+    @property
+    def image_height(self) -> int:
+        """The number of rows of pixels in the image."""
+
+    @property
+    def bits_per_sample(self) -> list[int]: ...
+    @property
+    def compression(self) -> Compression | int:
+        """Access the compression tag.
+
+        An `int` will be returned if the compression is not one of the values in
+        `Compression`.
+        """
+    @property
+    def photometric_interpretation(self) -> PhotometricInterpretation: ...
+    @property
+    def document_name(self) -> str | None: ...
+    @property
+    def image_description(self) -> str | None: ...
+    @property
+    def strip_offsets(self) -> list[int] | None: ...
+    @property
+    def orientation(self) -> int | None: ...
+    @property
+    def samples_per_pixel(self) -> int:
+        """
+        The number of components per pixel.
+
+        SamplesPerPixel is usually 1 for bilevel, grayscale, and palette-color images.
+        SamplesPerPixel is usually 3 for RGB images. If this value is higher,
+        ExtraSamples should give an indication of the meaning of the additional
+        channels.
+        """
+
+    @property
+    def rows_per_strip(self) -> int | None: ...
+    @property
+    def strip_byte_counts(self) -> int | None: ...
+    @property
+    def min_sample_value(self) -> int | None: ...
+    @property
+    def max_sample_value(self) -> int | None: ...
+    @property
+    def x_resolution(self) -> float | None:
+        """The number of pixels per ResolutionUnit in the ImageWidth direction."""
+
+    @property
+    def y_resolution(self) -> float | None:
+        """The number of pixels per ResolutionUnit in the ImageLength direction."""
+
+    @property
+    def planar_configuration(self) -> PlanarConfiguration: ...
+    @property
+    def resolution_unit(self) -> ResolutionUnit | None: ...
+    @property
+    def software(self) -> str | None: ...
+    @property
+    def date_time(self) -> str | None: ...
+    @property
+    def artist(self) -> str | None: ...
+    @property
+    def host_computer(self) -> str | None: ...
+    @property
+    def predictor(self) -> Predictor | None: ...
+    @property
+    def tile_width(self) -> int | None: ...
+    @property
+    def tile_height(self) -> int | None: ...
+    @property
+    def tile_offsets(self) -> list[int] | None: ...
+    @property
+    def tile_byte_counts(self) -> list[int] | None: ...
+    @property
+    def extra_samples(self) -> list[int] | None: ...
+    @property
+    def sample_format(self) -> list[SampleFormat]: ...
+    @property
+    def jpeg_tables(self) -> bytes | None: ...
+    @property
+    def copyright(self) -> str | None: ...
+    @property
+    def geo_key_directory(self) -> GeoKeyDirectory | None: ...
+    @property
+    def model_pixel_scale(self) -> list[float] | None: ...
+    @property
+    def model_tiepoint(self) -> list[float] | None: ...
+    @property
+    def model_transformation(self) -> list[float] | None: ...
+    @property
+    def gdal_nodata(self) -> str | None: ...
+    @property
+    def gdal_metadata(self) -> str | None: ...
+    @property
+    def other_tags(self) -> dict[int, Value]: ...
+    @property
+    def colormap(self) -> Colormap | None:
+        """The colormap for palette-color images."""
+        ...
+    async def fetch_tile(self, x: int, y: int) -> Tile:
+        """Fetch a single tile.
+
+        Args:
+            x: The column index within the ifd to read from.
+            y: The row index within the ifd to read from.
+
+        Returns:
+            Tile response.
+        """
+    async def fetch_tiles(self, x: Sequence[int], y: Sequence[int]) -> list[Tile]:
+        """Fetch multiple tiles concurrently.
+
+        Args:
+            x: The column indexes within the ifd to read from.
+            y: The row indexes within the ifd to read from.
+
+        Returns:
+            Tile responses.
+        """

async_tiff/_input.py

@@ -0,0 +1,8 @@
+from typing import Protocol
+
+# Fix exports
+from obspec._get import GetRangeAsync, GetRangesAsync
+
+
+class ObspecInput(GetRangeAsync, GetRangesAsync, Protocol):
+    """Supported obspec input to reader."""

async_tiff/_thread_pool.pyi

@@ -0,0 +1,4 @@
+class ThreadPool:
+    """A Rust-managed thread pool."""
+    def __init__(self, num_threads: int) -> None:
+        """Construct a new ThreadPool with the given number of threads."""

async_tiff/_tiff.pyi

@@ -0,0 +1,78 @@
+from typing import Sequence
+
+from ._ifd import ImageFileDirectory
+from ._input import ObspecInput
+from ._tile import Tile
+from .enums import Endianness
+from .store import ObjectStore
+
+class TIFF:
+    @classmethod
+    async def open(
+        cls,
+        path: str,
+        *,
+        store: ObjectStore | ObspecInput,
+        prefetch: int = 32768,
+        multiplier: int | float = 2.0,
+    ) -> TIFF:
+        """Open a new TIFF.
+
+        Args:
+            path: The path within the store to read from.
+            store: The backend to use for data fetching.
+            prefetch: The number of initial bytes to read up front.
+            multiplier: The multiplier to use for readahead size growth. Must be
+                greater than 1.0. For example, for a value of `2.0`, the first metadata
+                read will be of size `prefetch`, and then the next read will be of size
+                `prefetch * 2`.
+
+        Returns:
+            A TIFF instance.
+        """
+
+    @property
+    def endianness(self) -> Endianness:
+        """The endianness of this TIFF file."""
+
+    def ifd(self, index: int) -> ImageFileDirectory:
+        """Access a specific IFD by index.
+
+        Args:
+            index: The IFD index to access.
+
+        Returns:
+            The requested IFD.
+        """
+
+    @property
+    def ifds(self) -> list[ImageFileDirectory]:
+        """Access the underlying IFDs of this TIFF.
+
+        Each ImageFileDirectory (IFD) represents one of the internal "sub images" of
+        this file.
+        """
+    async def fetch_tile(self, x: int, y: int, z: int) -> Tile:
+        """Fetch a single tile.
+
+        Args:
+            x: The column index within the ifd to read from.
+            y: The row index within the ifd to read from.
+            z: The IFD index to read from.
+
+        Returns:
+            Tile response.
+        """
+    async def fetch_tiles(
+        self, x: Sequence[int], y: Sequence[int], z: int
+    ) -> list[Tile]:
+        """Fetch multiple tiles concurrently.
+
+        Args:
+            x: The column indexes within the ifd to read from.
+            y: The row indexes within the ifd to read from.
+            z: The IFD index to read from.
+
+        Returns:
+            Tile responses.
+        """

async_tiff/_tile.pyi

@@ -0,0 +1,58 @@
+from collections.abc import Buffer
+
+from ._array import Array
+from ._decoder import DecoderRegistry
+from ._thread_pool import ThreadPool
+from .enums import Compression
+
+class Tile:
+    """A representation of a TIFF image tile."""
+    @property
+    def x(self) -> int:
+        """The column index this tile represents."""
+    @property
+    def y(self) -> int:
+        """The row index this tile represents."""
+    @property
+    def compressed_bytes(self) -> Buffer:
+        """The compressed bytes underlying this tile."""
+    @property
+    def compression_method(self) -> Compression | int:
+        """The compression method used by this tile."""
+    def decode_sync(
+        self,
+        *,
+        decoder_registry: DecoderRegistry | None = None,
+    ) -> Array:
+        """Decode this tile's data.
+
+        **Note**: This is a blocking function and will perform the tile decompression on
+        the current thread. Prefer using the asynchronous `decode` method, which will
+        offload decompression to a thread pool.
+
+        Keyword Args:
+            decoder_registry: the decoders to use for decompression. Defaults to None, in which case a default decoder registry is used.
+
+        Returns:
+            Decoded tile data as an Array instance.
+        """
+
+    async def decode(
+        self,
+        *,
+        decoder_registry: DecoderRegistry | None = None,
+        pool: ThreadPool | None = None,
+    ) -> Array:
+        """Decode this tile's data.
+
+        This is an asynchronous function that will offload the tile decompression to a
+        thread pool.
+
+        Keyword Args:
+            decoder_registry: the decoders to use for decompression. Defaults to None, in which case a default decoder registry is used.
+            pool: the thread pool on which to run decompression. Defaults to None, in
+                which case, a default thread pool is used.
+
+        Returns:
+            Decoded tile data as an Array instance.
+        """

async_tiff/enums.py

@@ -0,0 +1,64 @@
+from enum import IntEnum
+
+
+class Compression(IntEnum):
+    """
+    See [TIFF compression
+    tags](https://www.awaresystems.be/imaging/tiff/tifftags/compression.html) for
+    reference.
+    """
+
+    Uncompressed = 1
+    Huffman = 2
+    Fax3 = 3
+    Fax4 = 4
+    LZW = 5
+    JPEG = 6
+    # // "Extended JPEG" or "new JPEG" style
+    ModernJPEG = 7
+    Deflate = 8
+    OldDeflate = 0x80B2
+    PackBits = 0x8005
+    WebP = 50001
+    JPEG2k = 34712
+    ZSTD = 0xC350
+
+
+class Endianness(IntEnum):
+    LittleEndian = 0
+    BigEndian = 1
+
+
+class PhotometricInterpretation(IntEnum):
+    WhiteIsZero = 0
+    BlackIsZero = 1
+    RGB = 2
+    RGBPalette = 3
+    TransparencyMask = 4
+    CMYK = 5
+    YCbCr = 6
+    CIELab = 8
+
+
+class PlanarConfiguration(IntEnum):
+    Chunky = 1
+    Planar = 2
+
+
+class Predictor(IntEnum):
+    Unknown = 1
+    Horizontal = 2
+    FloatingPoint = 3
+
+
+class ResolutionUnit(IntEnum):
+    Unknown = 1
+    Inch = 2
+    Centimeter = 3
+
+
+class SampleFormat(IntEnum):
+    Uint = 1
+    Int = 2
+    Float = 3
+    Void = 4

async_tiff-0.5.0b2.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: async-tiff
+Version: 0.5.0b2
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: obspec>=0.1.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# async-tiff
+
+[![PyPI][pypi_badge]][pypi_link]
+
+[pypi_badge]: https://badge.fury.io/py/async-tiff.svg
+[pypi_link]: https://pypi.org/project/async-tiff/
+
+Fast, low-level async TIFF reader for Python.
+
+This documentation is for the Python bindings. [Refer here for the Rust crate documentation](https://docs.rs/async-tiff).
+
+For a higher-level API to read GeoTIFF files, visit [`async-geotiff`][async-geotiff].
+
+[async-geotiff]: https://developmentseed.org/async-geotiff
+
+## Examples
+
+### Reading NAIP
+
+```py
+from async_tiff import TIFF
+from async_tiff.store import S3Store
+
+# You'll also need to provide credentials to access a requester pays bucket
+store = S3Store("naip-visualization", region="us-west-2", request_payer=True)
+path = "ny/2022/60cm/rgb/40073/m_4007307_sw_18_060_20220803.tif"
+
+tiff = await TIFF.open(path, store=store)
+primary_ifd = tiff.ifds[0]
+
+primary_ifd.geo_key_directory.citation
+# 'NAD83 / UTM zone 18N'
+
+primary_ifd.geo_key_directory.projected_type
+# 26918
+# (EPSG code)
+
+primary_ifd.sample_format
+# [<SampleFormat.Uint: 1>, <SampleFormat.Uint: 1>, <SampleFormat.Uint: 1>]
+
+primary_ifd.bits_per_sample
+# [8, 8, 8]
+
+tile = await tiff.fetch_tile(0, 0, 4)
+array = await tile.decode()
+
+# Use rasterio and matplotlib for visualization
+import numpy as np
+from rasterio.plot import reshape_as_raster, show
+
+# Zero-copy conversion of the rust array into a numpy array
+np_array = np.asarray(array)
+
+# Then we need to reshape the "image" axes into "raster" axes
+# https://rasterio.readthedocs.io/en/stable/topics/image_processing.html
+show(reshape_as_raster(np_array), adjust=True)
+```
+
+![](assets/naip-example.jpg)
+
+
+### Reading Sentinel 2 L2A
+
+```py
+import numpy as np
+from async_tiff import TIFF
+from async_tiff.store import S3Store
+
+store = S3Store("sentinel-cogs", region="us-west-2", skip_signature=True)
+path = "sentinel-s2-l2a-cogs/12/S/UF/2022/6/S2B_12SUF_20220609_0_L2A/B04.tif"
+
+tiff = await TIFF.open(path, store=store)
+primary_ifd = tiff.ifds[0]
+# Text readable citation
+primary_ifd.geo_key_directory.citation
+# EPSG code
+primary_ifd.geo_key_directory.projected_type
+
+primary_ifd.sample_format[0]
+# <SampleFormat.Uint: 1>
+primary_ifd.bits_per_sample[0]
+# 16
+
+tile = await tiff.fetch_tile(0, 0, 0)
+array = await tile.decode()
+
+# Zero-copy conversion of the rust array into a numpy array
+np_array = np.asarray(array)
+np_array.shape
+# (1024, 1024, 1)
+```
+
+

async_tiff-0.5.0b2.dist-info/RECORD

@@ -0,0 +1,19 @@
+async_tiff/__init__.py,sha256=hFou5CyaCeqAHIpsxyfNv28t15tehoFv7iLbgchVW54,579
+async_tiff/_array.pyi,sha256=muitV2BmObMPBF1O1mgo9a89posx7-ubsl4XftG5WO4,1257
+async_tiff/_async_tiff.abi3.so,sha256=d196ogZJQgtl3U20dyE8yL2kPSRpb-bV11txPtzClzU,9519873
+async_tiff/_async_tiff.pyi,sha256=I0Z9ey5GYZYfjJB4ZEyPUzHTsw0GcA5KBrAbTiThMc8,410
+async_tiff/_colormap.pyi,sha256=NrXLqUq3U81bI0zG8OLgQwv_JM0YS-MrVgx-1nD6j3g,402
+async_tiff/_decoder.pyi,sha256=tRHzZbZj1V6lDireFpNQ-f2h2tPFqh2ExYu4L6v0Cqc,709
+async_tiff/_decoder_runtime.py,sha256=N2IC7XTgC1TmGmB7ZXCJbrVVSbn6G85cWgJ6k87XpT8,553
+async_tiff/_geo.pyi,sha256=h71Y9zZ5vYxXaXAR4QAYmBJ0FOhLfXMMJA85p474eTE,3451
+async_tiff/_ifd.pyi,sha256=eKH2FAboDE3B5kK2U45j0RsN5MwD3cUeDVF5WTgu0as,4755
+async_tiff/_input.py,sha256=f6FCam4uyKaWXy-npUQ-nePaXeOsWMdXt2WcyH5fhq0,203
+async_tiff/_thread_pool.pyi,sha256=fbDu9kbo8RNlq7bBBxuuu_6ub20L5cAfXBM-J7Y0PC8,181
+async_tiff/_tiff.pyi,sha256=8MtZcmOPjr72lo8ohNuSwRi9N8YRZBtcjZwwJxEAO0Q,2249
+async_tiff/_tile.pyi,sha256=NBUciMH6nan6qQLt30p9msUiY4BKh4ZmW4r9CsqtYho,1961
+async_tiff/enums.py,sha256=C1XnevNtV_Hp5gTU7pLZRsNAfNx-4nu_f1NpbE1dN0U,1030
+async_tiff/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+async_tiff-0.5.0b2.dist-info/METADATA,sha256=50rXi50a5Ku3aism82VG4fsq0XisM-DsVDykkRdjGWQ,2741
+async_tiff-0.5.0b2.dist-info/WHEEL,sha256=TYQL8ukwJ_ep9kIEzr9pEuvjwsu8H5iF24nWE7u_TGo,107
+async_tiff.libs/libgcc_s-f685abf1.so.1,sha256=rZiUpi-nw8tNSOJeN-vr3RTEAMCMaHf73gTNGVqRdKs,536145
+async_tiff-0.5.0b2.dist-info/RECORD,,

async_tiff-0.5.0b2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp311-abi3-musllinux_1_2_x86_64