async-geotiff 0.1.0b1__py3-none-any.whl

async_geotiff/__init__.py

@@ -0,0 +1,10 @@
+"""Async GeoTIFF and [Cloud-Optimized GeoTIFF][cogeo] (COG) reader for Python.
+
+[cogeo]: https://cogeo.org/
+"""
+
+from ._geotiff import GeoTIFF
+from ._overview import Overview
+from ._version import __version__
+
+__all__ = ["GeoTIFF", "Overview", "__version__"]

async_geotiff/_crs.py

@@ -0,0 +1,621 @@
+"""Parse a pyproj CRS from a GeoKeyDirectory.
+
+In the simple case, a GeoTIFF is defined by an EPSG code, which we can pass to
+`pyproj.CRS.from_epsg`.
+
+In the complex case, a GeoTIFF is defined by a set of geo keys that specify all
+the parameters of a user-defined CRS. In this case, we need to build a PROJJSON
+dictionary representing the CRS, which we can then pass to `pyproj.CRS.from_json_dict`.
+
+Most of the code to construct a custom PROJJSON is generated by Claude. For any files
+where CRS generation fails, we should add a new test case in `test_crs.py`.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pyproj import CRS
+
+if TYPE_CHECKING:
+    from async_tiff import GeoKeyDirectory
+
+MODEL_TYPE_PROJECTED = 1
+"""GeoTIFF model type constant for projected coordinate systems."""
+
+MODEL_TYPE_GEOGRAPHIC = 2
+"""GeoTIFF model type constant for geographic coordinate systems."""
+
+USER_DEFINED_CRS = 32767
+"""Sentinel value for user-defined CRS."""
+
+# The two "public" functions of this module
+__all__ = ["crs_from_geo_keys", "projjson_from_geo_keys"]
+
+
+def crs_from_geo_keys(gkd: GeoKeyDirectory) -> CRS:
+    """Parse a pyproj CRS from a GeoKeyDirectory.
+
+    Supports both EPSG-coded and user-defined CRSes.
+    """
+    model_type = gkd.model_type
+
+    if model_type == MODEL_TYPE_PROJECTED:
+        crs = _projected_projection(gkd)
+        if isinstance(crs, int):
+            return CRS.from_epsg(crs)
+
+        return CRS.from_json_dict(crs)
+
+    if model_type == MODEL_TYPE_GEOGRAPHIC:
+        crs = _geographic_projection(gkd)
+        if isinstance(crs, int):
+            return CRS.from_epsg(crs)
+
+        return CRS.from_json_dict(crs)
+
+    raise ValueError(f"Unsupported GeoTIFF model type: {model_type}")
+
+
+def projjson_from_geo_keys(gkd: GeoKeyDirectory) -> dict:
+    """Build a PROJJSON dict from a GeoKeyDirectory.
+
+    For EPSG-coded CRSes, resolves via pyproj and returns the canonical
+    PROJJSON.
+
+    For user-defined CRSes, constructs the PROJJSON from individual
+    geo key parameters.
+    """
+    model_type = gkd.model_type
+
+    if model_type == MODEL_TYPE_PROJECTED:
+        crs = _projected_projection(gkd)
+        if isinstance(crs, int):
+            return CRS.from_epsg(crs).to_json_dict()
+
+        return crs
+
+    if model_type == MODEL_TYPE_GEOGRAPHIC:
+        crs = _geographic_projection(gkd)
+        if isinstance(crs, int):
+            return CRS.from_epsg(crs).to_json_dict()
+
+        return crs
+
+    raise ValueError(f"Unsupported GeoTIFF model type: {model_type}")
+
+
+def _geographic_projection(gkd: GeoKeyDirectory) -> int | dict:
+    """Infer the geographic CRS from geo keys.
+
+    If an EPSG code is present, returns that integer. Otherwise, constructs
+    a user-defined geographic CRS PROJJSON dict.
+    """
+    epsg = gkd.geographic_type
+    if epsg is not None and epsg != USER_DEFINED_CRS:
+        return epsg
+
+    return _build_user_defined_geographic_projjson(gkd)
+
+
+def _projected_projection(gkd: GeoKeyDirectory) -> int | dict:
+    """Infer the projected CRS from geo keys.
+
+    If an EPSG code is present, returns that integer. Otherwise, constructs
+    a user-defined projected CRS PROJJSON dict.
+    """
+    epsg = gkd.projected_type
+    if epsg is not None and epsg != USER_DEFINED_CRS:
+        return epsg
+
+    return _build_user_defined_projected_projjson(gkd)
+
+
+def _build_user_defined_geographic_projjson(gkd: GeoKeyDirectory) -> dict:
+    """Build a user-defined geographic CRS PROJJSON dict.
+
+    Constructs PROJJSON from the ellipsoid, datum, prime meridian, and angular
+    unit parameters stored in the GeoKeyDirectory.
+    """
+    # Build ellipsoid parameters
+    ellipsoid = _build_ellipsoid_params(gkd)
+
+    # Build prime meridian
+    pm_name = "Greenwich"
+    pm_longitude = 0.0
+    if (
+        gkd.geog_prime_meridian is not None
+        and gkd.geog_prime_meridian != USER_DEFINED_CRS
+    ):
+        # Known prime meridian by EPSG code
+        pm_name = f"EPSG:{gkd.geog_prime_meridian}"
+    elif gkd.geog_prime_meridian_long is not None:
+        pm_longitude = gkd.geog_prime_meridian_long
+        pm_name = "User-defined"
+
+    # Build datum
+    datum_json: dict
+    if (
+        gkd.geog_geodetic_datum is not None
+        and gkd.geog_geodetic_datum != USER_DEFINED_CRS
+    ):
+        datum_json = {
+            "type": "GeodeticReferenceFrame",
+            "name": f"Unknown datum based upon EPSG {gkd.geog_geodetic_datum} ellipsoid",  # noqa: E501
+        }
+    else:
+        datum_json = {
+            "type": "GeodeticReferenceFrame",
+            "name": gkd.geog_citation or "User-defined",
+            "ellipsoid": ellipsoid,
+            "prime_meridian": {
+                "name": pm_name,
+                "longitude": pm_longitude,
+            },
+        }
+
+    return {
+        "type": "GeographicCRS",
+        "$schema": "https://proj.org/schemas/v0.7/projjson.schema.json",
+        "name": gkd.geog_citation or "User-defined",
+        "datum": datum_json,
+        "coordinate_system": _geographic_cs(gkd),
+    }
+
+
+def _build_user_defined_projected_projjson(gkd: GeoKeyDirectory) -> dict:
+    """Build a user-defined projected CRS PROJJSON dict.
+
+    Constructs PROJJSON from the geographic base CRS and projection parameters
+    stored in the GeoKeyDirectory.
+    """
+    # Build the base geographic CRS as PROJJSON
+    base_crs = _geographic_projection(gkd)
+    if isinstance(base_crs, int):
+        base_crs_json = CRS.from_epsg(base_crs).to_json_dict()
+    else:
+        base_crs_json = base_crs
+
+    # Build the coordinate operation (projection)
+    conversion = _build_conversion(gkd)
+
+    # Build the coordinate system for the projected CRS
+    cs = _projected_cs(gkd)
+
+    return {
+        "type": "ProjectedCRS",
+        "$schema": "https://proj.org/schemas/v0.7/projjson.schema.json",
+        "name": gkd.proj_citation or "User-defined",
+        "base_crs": base_crs_json,
+        "conversion": conversion,
+        "coordinate_system": cs,
+    }
+
+
+def _build_ellipsoid_params(gkd: GeoKeyDirectory) -> dict:
+    """Build ellipsoid JSON parameters from geo keys."""
+    if gkd.geog_ellipsoid is not None and gkd.geog_ellipsoid != USER_DEFINED_CRS:
+        # Known ellipsoid by EPSG code — use parameters from geo keys if present
+        ellipsoid: dict = {"name": f"EPSG ellipsoid {gkd.geog_ellipsoid}"}
+
+        if gkd.geog_semi_major_axis is not None:
+            ellipsoid["semi_major_axis"] = gkd.geog_semi_major_axis
+        if gkd.geog_inv_flattening is not None:
+            ellipsoid["inverse_flattening"] = gkd.geog_inv_flattening
+        elif gkd.geog_semi_minor_axis is not None:
+            ellipsoid["semi_minor_axis"] = gkd.geog_semi_minor_axis
+
+        return ellipsoid
+
+    # Fully user-defined ellipsoid
+    semi_major = gkd.geog_semi_major_axis
+    if semi_major is None:
+        raise ValueError("User-defined ellipsoid requires geog_semi_major_axis")
+
+    user_ellipsoid: dict = {
+        "name": "User-defined",
+        "semi_major_axis": semi_major,
+    }
+
+    if gkd.geog_inv_flattening is not None:
+        user_ellipsoid["inverse_flattening"] = gkd.geog_inv_flattening
+    elif gkd.geog_semi_minor_axis is not None:
+        user_ellipsoid["semi_minor_axis"] = gkd.geog_semi_minor_axis
+    else:
+        raise ValueError(
+            "User-defined ellipsoid requires geog_inv_flattening or geog_semi_minor_axis",  # noqa: E501
+        )
+
+    return user_ellipsoid
+
+
+# GeoTIFF coordinate transformation type codes (GeoKey 3075)
+# Ref: http://geotiff.maptools.org/spec/geotiff6.html#6.3.3.3
+CT_TRANSVERSE_MERCATOR = 1
+CT_TRANSVERSE_MERCATOR_SOUTH = 2
+CT_OBLIQUE_MERCATOR = 3
+CT_OBLIQUE_MERCATOR_LABORDE = 4
+CT_OBLIQUE_MERCATOR_ROSENMUND = 5
+CT_OBLIQUE_MERCATOR_SPHERICAL = 6
+CT_MERCATOR = 7
+CT_LAMBERT_CONFORMAL_CONIC_2SP = 8
+CT_LAMBERT_CONFORMAL_CONIC_1SP = 9
+CT_LAMBERT_AZIMUTHAL_EQUAL_AREA = 10
+CT_ALBERS_EQUAL_AREA = 11
+CT_AZIMUTHAL_EQUIDISTANT = 12
+CT_STEREOGRAPHIC = 14
+CT_POLAR_STEREOGRAPHIC = 15
+CT_OBLIQUE_STEREOGRAPHIC = 16
+CT_EQUIRECTANGULAR = 17
+CT_CASSINI_SOLDNER = 18
+CT_ORTHOGRAPHIC = 21
+CT_POLYCONIC = 22
+CT_SINUSOIDAL = 24
+CT_NEW_ZEALAND_MAP_GRID = 26
+CT_TRANSVERSE_MERCATOR_SOUTH_ORIENTED = 27
+
+
+def _build_conversion(gkd: GeoKeyDirectory) -> dict:  # noqa: C901, PLR0912, PLR0915
+    """Build a PROJ JSON conversion (coordinate operation) from geo keys."""
+    ct = gkd.proj_coord_trans
+    if ct is None:
+        raise ValueError("User-defined projected CRS requires proj_coord_trans")
+
+    # Helper to build a projection parameter with unit
+    def _angular(name: str, value: float | None, default: float = 0.0) -> dict:
+        return {
+            "name": name,
+            "value": value if value is not None else default,
+            "unit": "degree",
+        }
+
+    def _linear(name: str, value: float | None, default: float = 0.0) -> dict:
+        return {
+            "name": name,
+            "value": value if value is not None else default,
+            "unit": "metre",
+        }
+
+    def _scale(name: str, value: float | None, default: float = 1.0) -> dict:
+        return {
+            "name": name,
+            "value": value if value is not None else default,
+            "unit": "unity",
+        }
+
+    name = "User-defined"
+    method: dict
+    parameters: list[dict]
+
+    if ct == CT_TRANSVERSE_MERCATOR:
+        name = "Transverse Mercator"
+        method = {"name": "Transverse Mercator"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_nat_origin_lat),
+            _angular("Longitude of natural origin", gkd.proj_nat_origin_long),
+            _scale("Scale factor at natural origin", gkd.proj_scale_at_nat_origin),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_TRANSVERSE_MERCATOR_SOUTH:
+        name = "Transverse Mercator (South Orientated)"
+        method = {"name": "Transverse Mercator (South Orientated)"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_nat_origin_lat),
+            _angular("Longitude of natural origin", gkd.proj_nat_origin_long),
+            _scale("Scale factor at natural origin", gkd.proj_scale_at_nat_origin),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct in (
+        CT_OBLIQUE_MERCATOR,
+        CT_OBLIQUE_MERCATOR_LABORDE,
+        CT_OBLIQUE_MERCATOR_ROSENMUND,
+        CT_OBLIQUE_MERCATOR_SPHERICAL,
+    ):
+        name = "Hotine Oblique Mercator (variant B)"
+        method = {"name": "Hotine Oblique Mercator (variant B)"}
+        parameters = [
+            _angular("Latitude of projection centre", gkd.proj_center_lat),
+            _angular("Longitude of projection centre", gkd.proj_center_long),
+            _angular("Azimuth of initial line", gkd.proj_azimuth_angle),
+            _angular("Angle from Rectified to Skew Grid", gkd.proj_azimuth_angle),
+            _scale("Scale factor on initial line", gkd.proj_scale_at_center),
+            _linear("Easting at projection centre", gkd.proj_center_easting),
+            _linear("Northing at projection centre", gkd.proj_center_northing),
+        ]
+
+    elif ct == CT_MERCATOR:
+        name = "Mercator (variant A)"
+        method = {"name": "Mercator (variant A)"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_nat_origin_lat),
+            _angular("Longitude of natural origin", gkd.proj_nat_origin_long),
+            _scale("Scale factor at natural origin", gkd.proj_scale_at_nat_origin),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_LAMBERT_CONFORMAL_CONIC_2SP:
+        name = "Lambert Conic Conformal (2SP)"
+        method = {"name": "Lambert Conic Conformal (2SP)"}
+        parameters = [
+            _angular(
+                "Latitude of false origin",
+                gkd.proj_false_origin_lat or gkd.proj_nat_origin_lat,
+            ),
+            _angular(
+                "Longitude of false origin",
+                gkd.proj_false_origin_long or gkd.proj_nat_origin_long,
+            ),
+            _angular("Latitude of 1st standard parallel", gkd.proj_std_parallel1),
+            _angular("Latitude of 2nd standard parallel", gkd.proj_std_parallel2),
+            _linear(
+                "Easting at false origin",
+                gkd.proj_false_origin_easting or gkd.proj_false_easting,
+            ),
+            _linear(
+                "Northing at false origin",
+                gkd.proj_false_origin_northing or gkd.proj_false_northing,
+            ),
+        ]
+
+    elif ct == CT_LAMBERT_CONFORMAL_CONIC_1SP:
+        name = "Lambert Conic Conformal (1SP)"
+        method = {"name": "Lambert Conic Conformal (1SP)"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_nat_origin_lat),
+            _angular("Longitude of natural origin", gkd.proj_nat_origin_long),
+            _scale("Scale factor at natural origin", gkd.proj_scale_at_nat_origin),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_LAMBERT_AZIMUTHAL_EQUAL_AREA:
+        name = "Lambert Azimuthal Equal Area"
+        method = {"name": "Lambert Azimuthal Equal Area"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_center_lat),
+            _angular("Longitude of natural origin", gkd.proj_center_long),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_ALBERS_EQUAL_AREA:
+        name = "Albers Equal Area"
+        method = {"name": "Albers Equal Area"}
+        parameters = [
+            _angular(
+                "Latitude of false origin",
+                gkd.proj_false_origin_lat or gkd.proj_nat_origin_lat,
+            ),
+            _angular(
+                "Longitude of false origin",
+                gkd.proj_false_origin_long or gkd.proj_nat_origin_long,
+            ),
+            _angular("Latitude of 1st standard parallel", gkd.proj_std_parallel1),
+            _angular("Latitude of 2nd standard parallel", gkd.proj_std_parallel2),
+            _linear(
+                "Easting at false origin",
+                gkd.proj_false_origin_easting or gkd.proj_false_easting,
+            ),
+            _linear(
+                "Northing at false origin",
+                gkd.proj_false_origin_northing or gkd.proj_false_northing,
+            ),
+        ]
+
+    elif ct == CT_AZIMUTHAL_EQUIDISTANT:
+        name = "Modified Azimuthal Equidistant"
+        method = {"name": "Modified Azimuthal Equidistant"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_center_lat),
+            _angular("Longitude of natural origin", gkd.proj_center_long),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_STEREOGRAPHIC:
+        name = "Stereographic"
+        method = {"name": "Stereographic"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_center_lat),
+            _angular("Longitude of natural origin", gkd.proj_center_long),
+            _scale("Scale factor at natural origin", gkd.proj_scale_at_center),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_POLAR_STEREOGRAPHIC:
+        name = "Polar Stereographic (variant B)"
+        method = {"name": "Polar Stereographic (variant B)"}
+        parameters = [
+            _angular(
+                "Latitude of standard parallel",
+                gkd.proj_nat_origin_lat or gkd.proj_std_parallel1,
+            ),
+            _angular(
+                "Longitude of origin",
+                gkd.proj_straight_vert_pole_long or gkd.proj_nat_origin_long,
+            ),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_OBLIQUE_STEREOGRAPHIC:
+        name = "Oblique Stereographic"
+        method = {"name": "Oblique Stereographic"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_center_lat),
+            _angular("Longitude of natural origin", gkd.proj_center_long),
+            _scale("Scale factor at natural origin", gkd.proj_scale_at_center),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_EQUIRECTANGULAR:
+        name = "Equidistant Cylindrical"
+        method = {"name": "Equidistant Cylindrical"}
+        parameters = [
+            _angular(
+                "Latitude of 1st standard parallel",
+                gkd.proj_std_parallel1 or gkd.proj_center_lat,
+            ),
+            _angular("Longitude of natural origin", gkd.proj_center_long),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_CASSINI_SOLDNER:
+        name = "Cassini-Soldner"
+        method = {"name": "Cassini-Soldner"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_nat_origin_lat),
+            _angular("Longitude of natural origin", gkd.proj_nat_origin_long),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_POLYCONIC:
+        name = "American Polyconic"
+        method = {"name": "American Polyconic"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_nat_origin_lat),
+            _angular("Longitude of natural origin", gkd.proj_nat_origin_long),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_SINUSOIDAL:
+        name = "Sinusoidal"
+        method = {"name": "Sinusoidal"}
+        parameters = [
+            _angular("Longitude of natural origin", gkd.proj_center_long),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_ORTHOGRAPHIC:
+        name = "Orthographic"
+        method = {"name": "Orthographic"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_center_lat),
+            _angular("Longitude of natural origin", gkd.proj_center_long),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_NEW_ZEALAND_MAP_GRID:
+        name = "New Zealand Map Grid"
+        method = {"name": "New Zealand Map Grid"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_nat_origin_lat),
+            _angular("Longitude of natural origin", gkd.proj_nat_origin_long),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    elif ct == CT_TRANSVERSE_MERCATOR_SOUTH_ORIENTED:
+        name = "Transverse Mercator (South Orientated)"
+        method = {"name": "Transverse Mercator (South Orientated)"}
+        parameters = [
+            _angular("Latitude of natural origin", gkd.proj_nat_origin_lat),
+            _angular("Longitude of natural origin", gkd.proj_nat_origin_long),
+            _scale("Scale factor at natural origin", gkd.proj_scale_at_nat_origin),
+            _linear("False easting", gkd.proj_false_easting),
+            _linear("False northing", gkd.proj_false_northing),
+        ]
+
+    else:
+        raise ValueError(f"Unsupported coordinate transformation type: {ct}")
+
+    return {
+        "name": name,
+        "method": method,
+        "parameters": parameters,
+    }
+
+
+ANGULAR_UNIT_RADIAN = 9101
+"""EPSG code for radian angular unit."""
+
+ANGULAR_UNIT_DEGREE = 9102
+"""EPSG code for degree angular unit."""
+
+ANGULAR_UNIT_GRAD = 9105
+"""EPSG code for grad angular unit."""
+
+ANGULAR_UNIT: dict[int | None, str] = {
+    ANGULAR_UNIT_DEGREE: "degree",
+    ANGULAR_UNIT_RADIAN: "radian",
+    ANGULAR_UNIT_GRAD: "grad",
+}
+
+
+def _geographic_cs(gkd: GeoKeyDirectory) -> dict:
+    """Build a geographic coordinate system JSON dict from geo keys."""
+    angular_unit = ANGULAR_UNIT.get(
+        gkd.geog_angular_units,
+        "degree",
+    )
+
+    return {
+        "subtype": "ellipsoidal",
+        "axis": [
+            {
+                "name": "Latitude",
+                "abbreviation": "lat",
+                "direction": "north",
+                "unit": angular_unit,
+            },
+            {
+                "name": "Longitude",
+                "abbreviation": "lon",
+                "direction": "east",
+                "unit": angular_unit,
+            },
+        ],
+    }
+
+
+LINEAR_UNIT_METRE = 9001
+LINEAR_UNIT_FOOT = 9002
+LINEAR_UNIT_US_SURVEY_FOOT = 9003
+
+LINEAR_UNIT: dict[int | None, str | dict[str, str | float]] = {
+    LINEAR_UNIT_METRE: "metre",
+    LINEAR_UNIT_FOOT: "foot",
+    LINEAR_UNIT_US_SURVEY_FOOT: {
+        "type": "LinearUnit",
+        "name": "US survey foot",
+        "conversion_factor": 0.30480060960121924,
+    },
+}
+
+
+def _projected_cs(gkd: GeoKeyDirectory) -> dict:
+    """Build a projected coordinate system JSON dict from geo keys."""
+    linear_unit: str | dict[str, str | float] = LINEAR_UNIT.get(
+        gkd.proj_linear_units,
+        "metre",
+    )
+
+    return {
+        "subtype": "Cartesian",
+        "axis": [
+            {
+                "name": "Easting",
+                "abbreviation": "E",
+                "direction": "east",
+                "unit": linear_unit,
+            },
+            {
+                "name": "Northing",
+                "abbreviation": "N",
+                "direction": "north",
+                "unit": linear_unit,
+            },
+        ],
+    }

async_geotiff/_geotiff.py

@@ -0,0 +1,405 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from functools import cached_property
+from typing import TYPE_CHECKING, Literal, Self
+
+from affine import Affine
+from async_tiff import TIFF
+from async_tiff.enums import PhotometricInterpretation
+
+from async_geotiff._crs import crs_from_geo_keys
+from async_geotiff._overview import Overview
+from async_geotiff.enums import Compression, Interleaving
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    import pyproj
+    from async_tiff import GeoKeyDirectory, ImageFileDirectory, ObspecInput
+    from async_tiff.store import ObjectStore  # type: ignore # noqa: PGH003
+
+
+@dataclass(frozen=True, init=False, kw_only=True, repr=False)
+class GeoTIFF:
+    """A class representing a GeoTIFF image."""
+
+    _tiff: TIFF
+    """The underlying async-tiff TIFF instance that we wrap.
+    """
+
+    _primary_ifd: ImageFileDirectory = field(init=False)
+    """The primary (first) IFD of the GeoTIFF.
+
+    Some tags, like most geo tags, only exist on the primary IFD.
+    """
+
+    _gkd: GeoKeyDirectory = field(init=False)
+    """The GeoKeyDirectory of the primary IFD.
+    """
+
+    _overviews: list[Overview] = field(init=False)
+    """A list of overviews for the GeoTIFF.
+    """
+
+    def __init__(self, tiff: TIFF) -> None:
+        """Create a GeoTIFF from an existing TIFF instance."""
+        first_ifd = tiff.ifds[0]
+        gkd = first_ifd.geo_key_directory
+
+        # Validate that this is indeed a GeoTIFF
+        if gkd is None:
+            raise ValueError("TIFF does not contain GeoTIFF keys")
+
+        if len(tiff.ifds) == 0:
+            raise ValueError("TIFF does not contain any IFDs")
+
+        # We use object.__setattr__ because the dataclass is frozen
+        object.__setattr__(self, "_tiff", tiff)
+        object.__setattr__(self, "_primary_ifd", first_ifd)
+        object.__setattr__(self, "_gkd", gkd)
+
+        # Skip the first IFD, since it's the primary image
+        ifd_idx = 1
+        overviews: list[Overview] = []
+        while True:
+            try:
+                data_ifd = (ifd_idx, tiff.ifds[ifd_idx])
+            except IndexError:
+                # No more IFDs
+                break
+
+            ifd_idx += 1
+
+            mask_ifd = None
+            next_ifd = None
+            try:
+                next_ifd = tiff.ifds[ifd_idx]
+            except IndexError:
+                # No more IFDs
+                pass
+            finally:
+                if next_ifd is not None and is_mask_ifd(next_ifd):
+                    mask_ifd = (ifd_idx, next_ifd)
+                    ifd_idx += 1
+
+            ovr = Overview._create(  # noqa: SLF001
+                geotiff=self,
+                gkd=gkd,
+                ifd=data_ifd,
+                mask_ifd=mask_ifd,
+            )
+            overviews.append(ovr)
+
+        object.__setattr__(self, "_overviews", overviews)
+
+    @classmethod
+    async def open(
+        cls,
+        path: str,
+        *,
+        store: ObjectStore | ObspecInput,
+        prefetch: int = 32768,
+        multiplier: float = 2.0,
+    ) -> Self:
+        """Open a new GeoTIFF.
+
+        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.
+
+        """
+        tiff = await TIFF.open(
+            path=path,
+            store=store,
+            prefetch=prefetch,
+            multiplier=multiplier,
+        )
+        return cls(tiff)
+
+    @property
+    def block_shapes(self) -> list[tuple[int, int]]:
+        """An ordered list of block shapes for each bands.
+
+        Shapes are tuples and have the same ordering as the dataset's shape:
+
+        - (count of image rows, count of image columns).
+        """
+        raise NotImplementedError
+
+    def block_size(self, bidx: int, i: int, j: int) -> int:
+        """Return the size in bytes of a particular block.
+
+        Args:
+            bidx: Band index, starting with 1.
+            i: Row index of the block, starting with 0.
+            j: Column index of the block, starting with 0.
+
+        """
+        raise NotImplementedError
+
+    @cached_property
+    def bounds(self) -> tuple[float, float, float, float]:
+        """Return the bounds of the dataset in the units of its CRS.
+
+        Returns:
+            (lower left x, lower left y, upper right x, upper right y)
+
+        """
+        transform = self.transform
+
+        # Hopefully types will be fixed with affine 3.0
+        (left, top) = transform * (0, 0)  # type: ignore # noqa: PGH003
+        (right, bottom) = transform * (self.width, self.height)  # type: ignore # noqa: PGH003
+
+        return (left, bottom, right, top)
+
+    @property
+    def colorinterp(self) -> list[str]:
+        """The color interpretation of each band in index order."""
+        # TODO: we should return an enum here. The enum should match rasterio.
+        # https://github.com/developmentseed/async-geotiff/issues/12
+        raise NotImplementedError
+
+    def colormap(self, bidx: int) -> dict[int, tuple[int, int, int]]:
+        """Return a dict containing the colormap for a band.
+
+        Args:
+            bidx: The 1-based index of the band whose colormap will be returned.
+
+        Returns:
+            Mapping of color index value (starting at 0) to RGBA color as a
+            4-element tuple.
+
+        Raises:
+            ValueError
+                If no colormap is found for the specified band (NULL color table).
+            IndexError
+                If no band exists for the provided index.
+
+        """
+        raise NotImplementedError
+
+    @property
+    def compression(self) -> Compression:
+        """The compression algorithm used for the dataset."""
+        # TODO: should return an enum. The enum should match rasterio.
+        # https://github.com/developmentseed/async-geotiff/issues/12
+        # Also, is there ever a case where overviews have a different compression from
+        # the base image?
+        # Should we diverge from rasterio and not have this as a property returning a
+        # single string?
+        raise NotImplementedError
+
+    @property
+    def count(self) -> int:
+        """The number of raster bands in the full image."""
+        raise NotImplementedError
+
+    @cached_property
+    def crs(self) -> pyproj.CRS:
+        """The dataset's coordinate reference system."""
+        return crs_from_geo_keys(self._gkd)
+
+    @property
+    def dtypes(self) -> list[str]:
+        """The data types of each band in index order."""
+        # TODO: not sure what the return type should be. Perhaps we should define a
+        # `DataType` enum?
+        # https://github.com/developmentseed/async-geotiff/issues/20
+        raise NotImplementedError
+
+    @property
+    def height(self) -> int:
+        """The height (number of rows) of the full image."""
+        return self._primary_ifd.image_height
+
+    def index(
+        self,
+        x: float,
+        y: float,
+        op: Callable[[float, float], tuple[int, int]] | None = None,
+    ) -> tuple[int, int]:
+        """Get the (row, col) index of the pixel containing (x, y).
+
+        Args:
+            x: x value in coordinate reference system
+            y: y value in coordinate reference system
+            op: function, optional (default: numpy.floor)
+                Function to convert fractional pixels to whole numbers
+                (floor, ceiling, round)
+
+        Returns:
+            (row index, col index)
+
+        """
+        raise NotImplementedError
+
+    def indexes(self) -> list[int]:
+        """Return the 1-based indexes of each band in the dataset.
+
+        For a 3-band dataset, this property will be [1, 2, 3].
+        """
+        return list(range(1, self._primary_ifd.samples_per_pixel + 1))
+
+    @property
+    def interleaving(self) -> Interleaving:
+        """The interleaving scheme of the dataset."""
+        # TODO: Should return an enum.
+        # https://rasterio.readthedocs.io/en/stable/api/rasterio.enums.html#rasterio.enums.Interleaving
+        raise NotImplementedError
+
+    @property
+    def is_tiled(self) -> bool:
+        """Check if the dataset is tiled."""
+        raise NotImplementedError
+
+    @property
+    def nodata(self) -> float | None:
+        """The dataset's single nodata value."""
+        nodata = self._primary_ifd.gdal_nodata
+        if nodata is None:
+            return None
+
+        return float(nodata)
+
+    @property
+    def overviews(self) -> list[Overview]:
+        """A list of overview levels for the dataset."""
+        return self._overviews
+
+    @property
+    def photometric(self) -> PhotometricInterpretation | None:
+        """The photometric interpretation of the dataset."""
+        # TODO: should return enum
+        # https://rasterio.readthedocs.io/en/stable/api/rasterio.enums.html#rasterio.enums.PhotometricInterp
+        raise NotImplementedError
+
+    @cached_property
+    def res(self) -> tuple[float, float]:
+        """Return the (width, height) of pixels in the units of its CRS."""
+        transform = self.transform
+        return (transform.a, -transform.e)
+
+    @property
+    def shape(self) -> tuple[int, int]:
+        """Get the shape (height, width) of the full image."""
+        return (self.height, self.width)
+
+    @cached_property
+    def transform(self) -> Affine:
+        """Return the dataset's georeferencing transformation matrix.
+
+        This transform maps pixel row/column coordinates to coordinates in the dataset's
+        CRS.
+        """
+        if (tie_points := self._primary_ifd.model_tiepoint) and (
+            model_scale := self._primary_ifd.model_pixel_scale
+        ):
+            x_origin = tie_points[3]
+            y_origin = tie_points[4]
+            x_resolution = model_scale[0]
+            y_resolution = -model_scale[1]
+
+            return Affine(x_resolution, 0, x_origin, 0, y_resolution, y_origin)
+
+        if model_transformation := self._primary_ifd.model_transformation:
+            # ModelTransformation is a 4x4 matrix in row-major order
+            # [0  1  2  3 ]   [a  b  0  c]
+            # [4  5  6  7 ] = [d  e  0  f]
+            # [8  9  10 11]   [0  0  1  0]
+            # [12 13 14 15]   [0  0  0  1]
+            x_origin = model_transformation[3]
+            y_origin = model_transformation[7]
+            row_rotation = model_transformation[1]
+            col_rotation = model_transformation[4]
+
+            # TODO: confirm these are correct
+            # Why does geotiff.js square and then square-root them?
+            # https://github.com/developmentseed/async-geotiff/issues/7
+            x_resolution = model_transformation[0]
+            y_resolution = -model_transformation[5]
+
+            return Affine(
+                model_transformation[0],
+                row_rotation,
+                x_origin,
+                col_rotation,
+                model_transformation[5],
+                y_origin,
+            )
+
+        raise ValueError("The image does not have an affine transformation.")
+
+    @property
+    def width(self) -> int:
+        """The width (number of columns) of the full image."""
+        return self._primary_ifd.image_width
+
+    def xy(
+        self,
+        row: int,
+        col: int,
+        offset: Literal["center", "ul", "ur", "ll", "lr"] | str = "center",
+    ) -> tuple[float, float]:
+        """Get the coordinates x, y of a pixel at row, col.
+
+        The pixel's center is returned by default, but a corner can be returned
+        by setting `offset` to one of `"ul"`, `"ur"`, `"ll"`, `"lr"`.
+
+        Args:
+            row: Pixel row.
+            col: Pixel column.
+            offset: Determines if the returned coordinates are for the center of the
+                pixel or for a corner.
+
+        """
+        transform = self.transform
+
+        if offset == "center":
+            c = col + 0.5
+            r = row + 0.5
+        elif offset == "ul":
+            c = col
+            r = row
+        elif offset == "ur":
+            c = col + 1
+            r = row
+        elif offset == "ll":
+            c = col
+            r = row + 1
+        elif offset == "lr":
+            c = col + 1
+            r = row + 1
+        else:
+            raise ValueError(f"Invalid offset value: {offset}")
+
+        return transform * (c, r)
+
+
+def has_geokeys(ifd: ImageFileDirectory) -> bool:
+    """Check if an IFD has GeoTIFF keys.
+
+    Args:
+        ifd: The IFD to check.
+
+    """
+    return ifd.geo_key_directory is not None
+
+
+def is_mask_ifd(ifd: ImageFileDirectory) -> bool:
+    """Check if an IFD is a mask IFD."""
+    return (
+        ifd.compression == Compression.deflate
+        and ifd.new_subfile_type is not None
+        and ifd.new_subfile_type & 4 != 0
+        and ifd.photometric_interpretation == PhotometricInterpretation.TransparencyMask
+    )

async_geotiff/_overview.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+from affine import Affine
+
+if TYPE_CHECKING:
+    from async_tiff import GeoKeyDirectory, ImageFileDirectory
+
+    from async_geotiff import GeoTIFF
+
+
+@dataclass(init=False, frozen=True, kw_only=True, eq=False, repr=False)
+class Overview:
+    """An overview level of a Cloud-Optimized GeoTIFF image."""
+
+    _geotiff: GeoTIFF
+    """A reference to the parent GeoTIFF object.
+    """
+
+    _gkd: GeoKeyDirectory
+    """The GeoKeyDirectory of the primary IFD.
+    """
+
+    _ifd: tuple[int, ImageFileDirectory]
+    """The IFD for this overview level.
+
+    (positional index of the IFD in the TIFF file, IFD object)
+    """
+
+    _mask_ifd: tuple[int, ImageFileDirectory] | None
+    """The IFD for the mask associated with this overview level, if any.
+
+    (positional index of the IFD in the TIFF file, IFD object)
+    """
+
+    @classmethod
+    def _create(
+        cls,
+        *,
+        geotiff: GeoTIFF,
+        gkd: GeoKeyDirectory,
+        ifd: tuple[int, ImageFileDirectory],
+        mask_ifd: tuple[int, ImageFileDirectory] | None,
+    ) -> Overview:
+        instance = cls.__new__(cls)
+
+        # We use object.__setattr__ because the dataclass is frozen
+        object.__setattr__(instance, "_geotiff", geotiff)
+        object.__setattr__(instance, "_gkd", gkd)
+        object.__setattr__(instance, "_ifd", ifd)
+        object.__setattr__(instance, "_mask_ifd", mask_ifd)
+
+        return instance
+
+    @property
+    def height(self) -> int:
+        """The height of the overview in pixels."""
+        return self._ifd[1].image_height
+
+    @cached_property
+    def transform(self) -> Affine:
+        """The affine transform mapping pixel coordinates to geographic coordinates.
+
+        Returns:
+            Affine: The affine transform.
+
+        """
+        full_transform = self._geotiff.transform
+
+        overview_width = self._ifd[1].image_width
+        full_width = self._geotiff.width
+        overview_height = self._ifd[1].image_height
+        full_height = self._geotiff.height
+
+        scale_x = full_width / overview_width
+        scale_y = full_height / overview_height
+
+        return full_transform * Affine.scale(scale_x, scale_y)
+
+    @property
+    def width(self) -> int:
+        """The width of the overview in pixels."""
+        return self._ifd[1].image_width

async_geotiff/_version.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("async-geotiff")
+except PackageNotFoundError:
+    __version__ = "uninstalled"

async_geotiff/enums.py

@@ -0,0 +1,59 @@
+"""Enums used by async_geotiff."""
+
+from enum import Enum, IntEnum
+
+# ruff: noqa: D101
+
+
+# https://github.com/rasterio/rasterio/blob/2d79e5f3a00e919ecaa9573adba34a78274ce48c/rasterio/enums.py#L153-L174
+class Compression(Enum):
+    """Available compression algorithms for GeoTIFFs.
+
+    Note that compression options for EXR, MRF, etc are not included
+    in this enum.
+    """
+
+    jpeg = "JPEG"
+    lzw = "LZW"
+    packbits = "PACKBITS"
+    deflate = "DEFLATE"
+    ccittrle = "CCITTRLE"
+    ccittfax3 = "CCITTFAX3"
+    ccittfax4 = "CCITTFAX4"
+    lzma = "LZMA"
+    none = "NONE"
+    zstd = "ZSTD"
+    lerc = "LERC"
+    lerc_deflate = "LERC_DEFLATE"
+    lerc_zstd = "LERC_ZSTD"
+    webp = "WEBP"
+    jpeg2000 = "JPEG2000"
+
+
+# https://github.com/rasterio/rasterio/blob/2d79e5f3a00e919ecaa9573adba34a78274ce48c/rasterio/enums.py#L177-L182
+class Interleaving(Enum):
+    pixel = "PIXEL"
+    line = "LINE"
+    band = "BAND"
+    #: tile requires GDAL 3.11+
+    tile = "TILE"
+
+
+# https://github.com/rasterio/rasterio/blob/2d79e5f3a00e919ecaa9573adba34a78274ce48c/rasterio/enums.py#L185-L189
+class MaskFlags(IntEnum):
+    all_valid = 1
+    per_dataset = 2
+    alpha = 4
+    nodata = 8
+
+
+# https://github.com/rasterio/rasterio/blob/2d79e5f3a00e919ecaa9573adba34a78274ce48c/rasterio/enums.py#L192-L200
+class PhotometricInterp(Enum):
+    black = "MINISBLACK"
+    white = "MINISWHITE"
+    rgb = "RGB"
+    cmyk = "CMYK"
+    ycbcr = "YCbCr"
+    cielab = "CIELAB"
+    icclab = "ICCLAB"
+    itulab = "ITULAB"

async_geotiff/tms.py

@@ -0,0 +1,141 @@
+"""Generate a Tile Matrix Set from a GeoTIFF file, using morecantile."""
+
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING
+from uuid import uuid4
+
+from morecantile.commons import BoundingBox
+from morecantile.models import (
+    CRS,
+    CRSWKT,
+    CRSUri,
+    TileMatrix,
+    TileMatrixSet,
+    TMSBoundingBox,
+)
+from morecantile.utils import meters_per_unit
+from pydantic import AnyUrl
+
+if TYPE_CHECKING:
+    from typing import Literal
+
+    import pyproj
+
+    from async_geotiff import GeoTIFF
+
+_SCREEN_PIXEL_SIZE = 0.28e-3
+
+__all__ = ["generate_tms"]
+
+
+def generate_tms(
+    geotiff: GeoTIFF,
+    *,
+    id: str = str(uuid4()),  # noqa: A002
+) -> TileMatrixSet:
+    """Generate a Tile Matrix Set from a GeoTIFF file.
+
+    Args:
+        geotiff: The GeoTIFF file to generate the TMS from.
+
+    Keyword Args:
+        id: The ID to assign to the Tile Matrix Set.
+
+    """
+    bounds = geotiff.bounds
+    crs = geotiff.crs
+    tr = geotiff.transform
+    blockxsize = geotiff._primary_ifd.tile_width  # noqa: SLF001
+    blockysize = geotiff._primary_ifd.tile_height  # noqa: SLF001
+
+    if blockxsize is None or blockysize is None:
+        raise ValueError("GeoTIFF must be tiled to generate a TMS.")
+
+    mpu = meters_per_unit(crs)
+
+    corner_of_origin: Literal["bottomLeft", "topLeft"] = (
+        "bottomLeft" if tr.e > 0 else "topLeft"
+    )
+
+    tile_matrices: list[TileMatrix] = []
+
+    for idx, overview in enumerate(reversed(geotiff.overviews)):
+        overview_tr = overview.transform
+        blockxsize = overview._ifd[1].tile_width  # noqa: SLF001
+        blockysize = overview._ifd[1].tile_height  # noqa: SLF001
+
+        if blockxsize is None or blockysize is None:
+            raise ValueError("GeoTIFF overviews must be tiled to generate a TMS.")
+
+        tile_matrices.append(
+            TileMatrix(
+                id=str(idx),
+                scaleDenominator=overview_tr.a * mpu / _SCREEN_PIXEL_SIZE,
+                cellSize=overview_tr.a,
+                cornerOfOrigin=corner_of_origin,
+                pointOfOrigin=(overview_tr.c, overview_tr.f),
+                tileWidth=blockxsize,
+                tileHeight=blockysize,
+                matrixWidth=math.ceil(overview.width / blockxsize),
+                matrixHeight=math.ceil(overview.height / blockysize),
+            ),
+        )
+
+    # Add the full-resolution level last
+    tile_matrices.append(
+        TileMatrix(
+            id=str(len(geotiff.overviews)),
+            scaleDenominator=tr.a * mpu / _SCREEN_PIXEL_SIZE,
+            cellSize=tr.a,
+            cornerOfOrigin=corner_of_origin,
+            pointOfOrigin=(tr.c, tr.f),
+            tileWidth=blockxsize,
+            tileHeight=blockysize,
+            matrixWidth=math.ceil(geotiff.width / blockxsize),
+            matrixHeight=math.ceil(geotiff.height / blockysize),
+        ),
+    )
+
+    bbox = BoundingBox(*bounds)
+    tms_crs = _parse_crs(crs)
+
+    return TileMatrixSet(
+        title="Generated TMS",
+        id=id,
+        crs=tms_crs,
+        boundingBox=TMSBoundingBox(
+            lowerLeft=(bbox.left, bbox.bottom),
+            upperRight=(bbox.right, bbox.top),
+            crs=tms_crs,
+        ),
+        tileMatrices=tile_matrices,
+    )
+
+
+def _parse_crs(
+    crs: pyproj.CRS,
+) -> CRS:
+    """Parse a pyproj CRS into a morecantile CRSUri or CRSWKT.
+
+    Args:
+        crs: The pyproj CRS to parse.
+
+    """
+    if authority_code := crs.to_authority(min_confidence=20):
+        authority, code = authority_code
+        version = "0"
+        # if we have a version number in the authority, split it out
+        if "_" in authority:
+            authority, version = authority.split("_")
+
+        return CRS(
+            CRSUri(
+                uri=AnyUrl(
+                    f"http://www.opengis.net/def/crs/{authority}/{version}/{code}",
+                ),
+            ),
+        )
+
+    return CRS(CRSWKT(wkt=crs.to_json_dict()))

async_geotiff-0.1.0b1.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.3
+Name: async-geotiff
+Version: 0.1.0b1
+Summary: Async GeoTIFF reader for Python
+Author: Kyle Barron
+Author-email: Kyle Barron <kyle@developmentseed.org>
+Requires-Dist: affine>=2.4.0
+Requires-Dist: async-tiff>=0.4.0
+Requires-Dist: numpy>2
+Requires-Dist: pyproj>=3.7.2
+Requires-Dist: morecantile>=7.0,<8.0 ; extra == 'morecantile'
+Requires-Python: >=3.11
+Provides-Extra: morecantile
+Description-Content-Type: text/markdown
+
+# async-geotiff
+
+Async GeoTIFF and [Cloud-Optimized GeoTIFF][cogeo] (COG) reader for Python, wrapping [`async-tiff`].
+
+[`async-tiff`]: https://github.com/developmentseed/async-tiff
+[cogeo]: https://cogeo.org/
+
+## Project Goals:
+
+- Support only for GeoTIFF and Cloud-Optimized GeoTIFF (COG) formats
+- Support for reading only, no writing support
+- Full type hinting.
+- API similar to rasterio where possible.
+    - We won't support the full rasterio API, but we'll try to when it's possible to implement rasterio APIs with straightforward maintenance requirements.
+    - For methods where we do intentionally try to match with rasterio, the tests should match against rasterio.
+- Initially, we'll try to support a core set of GeoTIFF formats. Obscure GeoTIFF files may not be supported.
+
+## References
+
+- aiocogeo: https://github.com/geospatial-jeff/aiocogeo

async_geotiff-0.1.0b1.dist-info/RECORD

@@ -0,0 +1,11 @@
+async_geotiff/__init__.py,sha256=Z_g9Z04lgDNeIOI4Z3lXn74G_7MOntwcPgjWBYLIoUU,259
+async_geotiff/_crs.py,sha256=upyEGDiuHyWniTD--blzujYHlXBvfHLCSPzgekvO26Q,22105
+async_geotiff/_geotiff.py,sha256=hEC0hR5qTB0DGEe4Cvoaz_56D-zfZeT9UR4lmjJD77w,13123
+async_geotiff/_overview.py,sha256=dsdbKpix3aebjtibfJSgLUbqSAY92tlMMcg3fVLFlfY,2423
+async_geotiff/_version.py,sha256=WOBh553JMD6VV-k_R8km_U4yt5mzyrWhi4OeTSXNoJI,171
+async_geotiff/enums.py,sha256=j-_K1UtI0tBzZ945auvhWZdktO1bgZp7Nf-K9c208IQ,1493
+async_geotiff/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+async_geotiff/tms.py,sha256=55nXenfss_KX7I5bmcMwtTHZWzNYAwSqhfjqSQju7OI,3922
+async_geotiff-0.1.0b1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+async_geotiff-0.1.0b1.dist-info/METADATA,sha256=gvy7Kywt1fjDiFl-HWxfmHHi3knCrHrC5MPzzoshMUc,1300
+async_geotiff-0.1.0b1.dist-info/RECORD,,

async_geotiff-0.1.0b1.dist-info/WHEEL

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