geoai-py 0.18.0__py2.py3-none-any.whl → 0.18.2__py2.py3-none-any.whl

geoai/__init__.py

@@ -2,7 +2,7 @@
 
 __author__ = """Qiusheng Wu"""
 __email__ = "giswqs@gmail.com"
-__version__ = "0.18.0"
+__version__ = "0.18.2"
 
 
 import os

geoai/train.py

@@ -2015,17 +2015,39 @@ def get_semantic_transform(train: bool) -> Any:
     """
     Get transforms for semantic segmentation data augmentation.
 
+    This function returns default data augmentation transforms for training
+    semantic segmentation models. The transforms include geometric transformations
+    (horizontal/vertical flips, rotations) and photometric adjustments (brightness,
+    contrast) that are commonly used in remote sensing tasks.
+
     Args:
         train (bool): Whether to include training-specific transforms.
+            If True, applies augmentations (flips, rotations, brightness/contrast adjustments).
+            If False, only converts to tensor (for validation).
 
     Returns:
         SemanticTransforms: Composed transforms.
+
+    Example:
+        >>> train_transform = get_semantic_transform(train=True)
+        >>> val_transform = get_semantic_transform(train=False)
     """
     transforms = []
     transforms.append(SemanticToTensor())
 
     if train:
+        # Geometric transforms - preserve spatial structure
         transforms.append(SemanticRandomHorizontalFlip(0.5))
+        transforms.append(SemanticRandomVerticalFlip(0.5))
+        transforms.append(SemanticRandomRotation90(0.5))
+
+        # Photometric transforms - improve model robustness
+        transforms.append(
+            SemanticBrightnessAdjustment(brightness_range=(0.8, 1.2), prob=0.5)
+        )
+        transforms.append(
+            SemanticContrastAdjustment(contrast_range=(0.8, 1.2), prob=0.5)
+        )
 
     return SemanticTransforms(transforms)
 

geoai/utils.py

@@ -64,7 +64,7 @@ def view_raster(
     client_args: Optional[Dict] = {"cors_all": False},
     basemap: Optional[str] = "OpenStreetMap",
     basemap_args: Optional[Dict] = None,
-    backend: Optional[str] = "ipyleaflet",
+    backend: Optional[str] = "folium",
     **kwargs: Any,
 ) -> Any:
     """
@@ -87,7 +87,7 @@ def view_raster(
         client_args (Optional[Dict], optional): Additional arguments for the client. Defaults to {"cors_all": False}.
         basemap (Optional[str], optional): The basemap to use. Defaults to "OpenStreetMap".
         basemap_args (Optional[Dict], optional): Additional arguments for the basemap. Defaults to None.
-        backend (Optional[str], optional): The backend to use. Defaults to "ipyleaflet".
+        backend (Optional[str], optional): The backend to use. Defaults to "folium".
         **kwargs (Any): Additional keyword arguments.
 
     Returns:
@@ -123,26 +123,39 @@ def view_raster(
     if isinstance(source, dict):
         source = dict_to_image(source)
 
-    if (
-        isinstance(source, str)
-        and source.lower().endswith(".tif")
-        and source.startswith("http")
-    ):
-        if indexes is not None:
-            kwargs["bidx"] = indexes
-        if colormap is not None:
-            kwargs["colormap_name"] = colormap
-        if attribution is None:
-            attribution = "TiTiler"
-
-        m.add_cog_layer(
-            source,
-            name=layer_name,
-            opacity=opacity,
-            attribution=attribution,
-            zoom_to_layer=zoom_to_layer,
-            **kwargs,
-        )
+    if isinstance(source, str) and source.startswith("http"):
+        if backend == "folium":
+
+            m.add_geotiff(
+                url=source,
+                name=layer_name,
+                opacity=opacity,
+                attribution=attribution,
+                fit_bounds=zoom_to_layer,
+                palette=colormap,
+                vmin=vmin,
+                vmax=vmax,
+                **kwargs,
+            )
+            m.add_layer_control()
+            m.add_opacity_control()
+
+        else:
+            if indexes is not None:
+                kwargs["bidx"] = indexes
+            if colormap is not None:
+                kwargs["colormap_name"] = colormap
+            if attribution is None:
+                attribution = "TiTiler"
+
+            m.add_cog_layer(
+                source,
+                name=layer_name,
+                opacity=opacity,
+                attribution=attribution,
+                zoom_to_layer=zoom_to_layer,
+                **kwargs,
+            )
     else:
         m.add_raster(
             source=source,
@@ -1081,8 +1094,9 @@ def view_vector(
 
 def view_vector_interactive(
     vector_data: Union[str, gpd.GeoDataFrame],
-    layer_name: str = "Vector Layer",
+    layer_name: str = "Vector",
     tiles_args: Optional[Dict] = None,
+    opacity: float = 0.7,
     **kwargs: Any,
 ) -> Any:
     """
@@ -1097,6 +1111,7 @@ def view_vector_interactive(
         layer_name (str, optional): The name of the layer. Defaults to "Vector Layer".
         tiles_args (dict, optional): Additional arguments for the localtileserver client.
             get_folium_tile_layer function. Defaults to None.
+        opacity (float, optional): The opacity of the layer. Defaults to 0.7.
         **kwargs: Additional keyword arguments to pass to GeoDataFrame.explore() function.
             See https://geopandas.org/en/stable/docs/reference/api/geopandas.GeoDataFrame.explore.html
 
@@ -1111,9 +1126,8 @@ def view_vector_interactive(
         >>> roads = gpd.read_file("roads.shp")
         >>> view_vector_interactive(roads, figsize=(12, 8))
     """
-    import folium
-    import folium.plugins as plugins
-    from leafmap import cog_tile
+
+    from leafmap.foliumap import Map
     from localtileserver import TileClient, get_folium_tile_layer
 
     google_tiles = {
@@ -1148,6 +1162,8 @@ def view_vector_interactive(
     basemap_layer_name = None
     raster_layer = None
 
+    m = Map()
+
     if "tiles" in kwargs and isinstance(kwargs["tiles"], str):
         if kwargs["tiles"].title() in google_tiles:
             basemap_layer_name = google_tiles[kwargs["tiles"].title()]["name"]
@@ -1158,14 +1174,17 @@ def view_vector_interactive(
                 tiles_args = {}
             if kwargs["tiles"].lower().startswith("http"):
                 basemap_layer_name = "Remote Raster"
-                kwargs["tiles"] = cog_tile(kwargs["tiles"], **tiles_args)
-                kwargs["attr"] = "TiTiler"
+                m.add_geotiff(kwargs["tiles"], name=basemap_layer_name, **tiles_args)
             else:
                 basemap_layer_name = "Local Raster"
                 client = TileClient(kwargs["tiles"])
                 raster_layer = get_folium_tile_layer(client, **tiles_args)
-                kwargs["tiles"] = raster_layer.tiles
-                kwargs["attr"] = "localtileserver"
+                m.add_tile_layer(
+                    raster_layer.tiles,
+                    name=basemap_layer_name,
+                    attribution="localtileserver",
+                    **tiles_args,
+                )
 
     if "max_zoom" not in kwargs:
         kwargs["max_zoom"] = 30
@@ -1180,23 +1199,18 @@ def view_vector_interactive(
     if not isinstance(vector_data, gpd.GeoDataFrame):
         raise TypeError("Input data must be a GeoDataFrame")
 
-    layer_control = kwargs.pop("layer_control", True)
-    fullscreen_control = kwargs.pop("fullscreen_control", True)
-
-    m = vector_data.explore(**kwargs)
+    if "column" in kwargs:
+        if "legend_position" not in kwargs:
+            kwargs["legend_position"] = "bottomleft"
+        if "cmap" not in kwargs:
+            kwargs["cmap"] = "viridis"
+        m.add_data(vector_data, layer_name=layer_name, opacity=opacity, **kwargs)
 
-    # Change the layer name
-    for layer in m._children.values():
-        if isinstance(layer, folium.GeoJson):
-            layer.layer_name = layer_name
-        if isinstance(layer, folium.TileLayer) and basemap_layer_name:
-            layer.layer_name = basemap_layer_name
-
-    if layer_control:
-        m.add_child(folium.LayerControl())
+    else:
+        m.add_gdf(vector_data, layer_name=layer_name, opacity=opacity, **kwargs)
 
-    if fullscreen_control:
-        plugins.Fullscreen().add_to(m)
+    m.add_layer_control()
+    m.add_opacity_control()
 
     return m
 
@@ -2990,6 +3004,82 @@ def batch_vector_to_raster(
     return output_files
 
 
+def get_default_augmentation_transforms(
+    tile_size: int = 256,
+    include_normalize: bool = False,
+    mean: Tuple[float, float, float] = (0.485, 0.456, 0.406),
+    std: Tuple[float, float, float] = (0.229, 0.224, 0.225),
+) -> Any:
+    """
+    Get default data augmentation transforms for geospatial imagery using albumentations.
+
+    This function returns a composition of augmentation transforms commonly used
+    for remote sensing and geospatial data. The transforms include geometric
+    transformations (flips, rotations) and photometric adjustments (brightness,
+    contrast, saturation).
+
+    Args:
+        tile_size (int): Target size for tiles. Defaults to 256.
+        include_normalize (bool): Whether to include normalization transform.
+            Defaults to False. Set to True if using for training with pretrained models.
+        mean (tuple): Mean values for normalization (RGB). Defaults to ImageNet values.
+        std (tuple): Standard deviation for normalization (RGB). Defaults to ImageNet values.
+
+    Returns:
+        albumentations.Compose: A composition of augmentation transforms.
+
+    Example:
+        >>> import albumentations as A
+        >>> # Get default transforms
+        >>> transform = get_default_augmentation_transforms()
+        >>> # Apply to image and mask
+        >>> augmented = transform(image=image, mask=mask)
+        >>> aug_image = augmented['image']
+        >>> aug_mask = augmented['mask']
+    """
+    try:
+        import albumentations as A
+    except ImportError:
+        raise ImportError(
+            "albumentations is required for data augmentation. "
+            "Install it with: pip install albumentations"
+        )
+
+    transforms_list = [
+        # Geometric transforms
+        A.HorizontalFlip(p=0.5),
+        A.VerticalFlip(p=0.5),
+        A.RandomRotate90(p=0.5),
+        A.ShiftScaleRotate(
+            shift_limit=0.1,
+            scale_limit=0.1,
+            rotate_limit=45,
+            border_mode=0,
+            p=0.5,
+        ),
+        # Photometric transforms
+        A.RandomBrightnessContrast(
+            brightness_limit=0.2,
+            contrast_limit=0.2,
+            p=0.5,
+        ),
+        A.HueSaturationValue(
+            hue_shift_limit=10,
+            sat_shift_limit=20,
+            val_shift_limit=10,
+            p=0.3,
+        ),
+        A.GaussNoise(var_limit=(10.0, 50.0), p=0.2),
+        A.GaussianBlur(blur_limit=(3, 5), p=0.2),
+    ]
+
+    # Add normalization if requested
+    if include_normalize:
+        transforms_list.append(A.Normalize(mean=mean, std=std))
+
+    return A.Compose(transforms_list)
+
+
 def export_geotiff_tiles(
     in_raster,
     out_folder,
@@ -3004,6 +3094,9 @@ def export_geotiff_tiles(
     create_overview=False,
     skip_empty_tiles=False,
     metadata_format="PASCAL_VOC",
+    apply_augmentation=False,
+    augmentation_count=3,
+    augmentation_transforms=None,
 ):
     """
     Export georeferenced GeoTIFF tiles and labels from raster and classification data.
@@ -3023,12 +3116,54 @@ def export_geotiff_tiles(
         create_overview (bool): Whether to create an overview image of all tiles
         skip_empty_tiles (bool): If True, skip tiles with no features
         metadata_format (str): Output metadata format (PASCAL_VOC, COCO, YOLO). Default: PASCAL_VOC
+        apply_augmentation (bool): If True, generate augmented versions of each tile.
+            This will create multiple variants of each tile using data augmentation techniques.
+            Defaults to False.
+        augmentation_count (int): Number of augmented versions to generate per tile
+            (only used if apply_augmentation=True). Defaults to 3.
+        augmentation_transforms (albumentations.Compose, optional): Custom augmentation transforms.
+            If None and apply_augmentation=True, uses default transforms from
+            get_default_augmentation_transforms(). Should be an albumentations.Compose object.
+            Defaults to None.
+
+    Returns:
+        None: Tiles and labels are saved to out_folder.
+
+    Example:
+        >>> # Export tiles without augmentation
+        >>> export_geotiff_tiles('image.tif', 'output/', 'labels.tif')
+        >>>
+        >>> # Export tiles with default augmentation (3 augmented versions per tile)
+        >>> export_geotiff_tiles('image.tif', 'output/', 'labels.tif',
+        ...                      apply_augmentation=True)
+        >>>
+        >>> # Export with custom augmentation
+        >>> import albumentations as A
+        >>> custom_transform = A.Compose([
+        ...     A.HorizontalFlip(p=0.5),
+        ...     A.RandomBrightnessContrast(p=0.5),
+        ... ])
+        >>> export_geotiff_tiles('image.tif', 'output/', 'labels.tif',
+        ...                      apply_augmentation=True,
+        ...                      augmentation_count=5,
+        ...                      augmentation_transforms=custom_transform)
     """
 
     import logging
 
     logging.getLogger("rasterio").setLevel(logging.ERROR)
 
+    # Initialize augmentation transforms if needed
+    if apply_augmentation:
+        if augmentation_transforms is None:
+            augmentation_transforms = get_default_augmentation_transforms(
+                tile_size=tile_size
+            )
+        if not quiet:
+            print(
+                f"Data augmentation enabled: generating {augmentation_count} augmented versions per tile"
+            )
+
     # Create output directories
     os.makedirs(out_folder, exist_ok=True)
     image_dir = os.path.join(out_folder, "images")
@@ -3360,53 +3495,134 @@ def export_geotiff_tiles(
                 # Read image data
                 image_data = src.read(window=window)
 
-                # Export image as GeoTIFF
-                image_path = os.path.join(image_dir, f"tile_{tile_index:06d}.tif")
+                # Helper function to save a single tile (original or augmented)
+                def save_tile(
+                    img_data,
+                    lbl_mask,
+                    tile_id,
+                    img_profile,
+                    window_trans,
+                    is_augmented=False,
+                ):
+                    """Save a single image and label tile."""
+                    # Export image as GeoTIFF
+                    image_path = os.path.join(image_dir, f"tile_{tile_id:06d}.tif")
 
-                # Create profile for image GeoTIFF
-                image_profile = src.profile.copy()
-                image_profile.update(
-                    {
-                        "height": tile_size,
-                        "width": tile_size,
-                        "count": image_data.shape[0],
-                        "transform": window_transform,
-                    }
+                    # Update profile
+                    img_profile_copy = img_profile.copy()
+                    img_profile_copy.update(
+                        {
+                            "height": tile_size,
+                            "width": tile_size,
+                            "count": img_data.shape[0],
+                            "transform": window_trans,
+                        }
+                    )
+
+                    # Save image as GeoTIFF
+                    try:
+                        with rasterio.open(image_path, "w", **img_profile_copy) as dst:
+                            dst.write(img_data)
+                        stats["total_tiles"] += 1
+                    except Exception as e:
+                        pbar.write(f"ERROR saving image GeoTIFF: {e}")
+                        stats["errors"] += 1
+                        return
+
+                    # Export label as GeoTIFF (only if class data provided)
+                    if in_class_data is not None:
+                        # Create profile for label GeoTIFF
+                        label_profile = {
+                            "driver": "GTiff",
+                            "height": tile_size,
+                            "width": tile_size,
+                            "count": 1,
+                            "dtype": "uint8",
+                            "crs": src.crs,
+                            "transform": window_trans,
+                        }
+
+                        label_path = os.path.join(label_dir, f"tile_{tile_id:06d}.tif")
+                        try:
+                            with rasterio.open(label_path, "w", **label_profile) as dst:
+                                dst.write(lbl_mask.astype(np.uint8), 1)
+
+                            if not is_augmented and np.any(lbl_mask > 0):
+                                stats["tiles_with_features"] += 1
+                                stats["feature_pixels"] += np.count_nonzero(lbl_mask)
+                        except Exception as e:
+                            pbar.write(f"ERROR saving label GeoTIFF: {e}")
+                            stats["errors"] += 1
+
+                # Save original tile
+                save_tile(
+                    image_data,
+                    label_mask,
+                    tile_index,
+                    src.profile,
+                    window_transform,
+                    is_augmented=False,
                 )
 
-                # Save image as GeoTIFF
-                try:
-                    with rasterio.open(image_path, "w", **image_profile) as dst:
-                        dst.write(image_data)
-                    stats["total_tiles"] += 1
-                except Exception as e:
-                    pbar.write(f"ERROR saving image GeoTIFF: {e}")
-                    stats["errors"] += 1
+                # Generate and save augmented tiles if enabled
+                if apply_augmentation:
+                    for aug_idx in range(augmentation_count):
+                        # Prepare image for augmentation (convert from CHW to HWC)
+                        img_for_aug = np.transpose(image_data, (1, 2, 0))
+
+                        # Ensure uint8 data type for albumentations
+                        # Albumentations expects uint8 for most transforms
+                        if not np.issubdtype(img_for_aug.dtype, np.uint8):
+                            # If image is float, scale to 0-255 and convert to uint8
+                            if np.issubdtype(img_for_aug.dtype, np.floating):
+                                img_for_aug = (
+                                    (img_for_aug * 255).clip(0, 255).astype(np.uint8)
+                                )
+                            else:
+                                img_for_aug = img_for_aug.astype(np.uint8)
 
-                # Export label as GeoTIFF (only if class data provided)
-                if in_class_data is not None:
-                    # Create profile for label GeoTIFF
-                    label_profile = {
-                        "driver": "GTiff",
-                        "height": tile_size,
-                        "width": tile_size,
-                        "count": 1,
-                        "dtype": "uint8",
-                        "crs": src.crs,
-                        "transform": window_transform,
-                    }
+                        # Apply augmentation
+                        try:
+                            if in_class_data is not None:
+                                # Augment both image and mask
+                                augmented = augmentation_transforms(
+                                    image=img_for_aug, mask=label_mask
+                                )
+                                aug_image = augmented["image"]
+                                aug_mask = augmented["mask"]
+                            else:
+                                # Augment only image
+                                augmented = augmentation_transforms(image=img_for_aug)
+                                aug_image = augmented["image"]
+                                aug_mask = label_mask
 
-                    label_path = os.path.join(label_dir, f"tile_{tile_index:06d}.tif")
-                    try:
-                        with rasterio.open(label_path, "w", **label_profile) as dst:
-                            dst.write(label_mask.astype(np.uint8), 1)
+                            # Convert back from HWC to CHW
+                            aug_image = np.transpose(aug_image, (2, 0, 1))
 
-                        if has_features:
-                            stats["tiles_with_features"] += 1
-                            stats["feature_pixels"] += np.count_nonzero(label_mask)
-                    except Exception as e:
-                        pbar.write(f"ERROR saving label GeoTIFF: {e}")
-                        stats["errors"] += 1
+                            # Ensure correct dtype for saving
+                            aug_image = aug_image.astype(image_data.dtype)
+
+                            # Generate unique tile ID for augmented version
+                            # Use a collision-free numbering scheme: (tile_index * (augmentation_count + 1)) + aug_idx + 1
+                            aug_tile_id = (
+                                (tile_index * (augmentation_count + 1)) + aug_idx + 1
+                            )
+
+                            # Save augmented tile
+                            save_tile(
+                                aug_image,
+                                aug_mask,
+                                aug_tile_id,
+                                src.profile,
+                                window_transform,
+                                is_augmented=True,
+                            )
+
+                        except Exception as e:
+                            pbar.write(
+                                f"ERROR applying augmentation {aug_idx} to tile {tile_index}: {e}"
+                            )
+                            stats["errors"] += 1
 
                 # Create annotations for object detection if using vector class data
                 if (

{geoai_py-0.18.0.dist-info → geoai_py-0.18.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geoai-py
-Version: 0.18.0
+Version: 0.18.2
 Summary: A Python package for using Artificial Intelligence (AI) with geospatial data
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT License
@@ -24,7 +24,7 @@ Requires-Dist: ever-beta
 Requires-Dist: geopandas
 Requires-Dist: huggingface_hub
 Requires-Dist: jupyter-server-proxy
-Requires-Dist: leafmap
+Requires-Dist: leafmap>=0.57.1
 Requires-Dist: localtileserver
 Requires-Dist: mapclassify
 Requires-Dist: maplibre

{geoai_py-0.18.0.dist-info → geoai_py-0.18.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-geoai/__init__.py,sha256=9wW42cjIMMY_ec5s-DOO04XgQHXVre8CisL72wvJCIU,4620
+geoai/__init__.py,sha256=2-Zd8r21PkzvPRpTIE45FtTyJNURGvSNOBlbr_2o9P8,4620
 geoai/change_detection.py,sha256=pdQofnPRiwoES8vMln2vHghRnpeTdsmqLir74dnqZYU,60389
 geoai/classify.py,sha256=0DcComVR6vKU4qWtH2oHVeXc7ZTcV0mFvdXRtlNmolo,35637
 geoai/detectron2.py,sha256=dOOFM9M9-6PV8q2A4-mnIPrz7yTo-MpEvDiAW34nl0w,14610
@@ -13,8 +13,8 @@ geoai/segment.py,sha256=yBGTxA-ti8lBpk7WVaBOp6yP23HkaulKJQk88acrmZ0,43788
 geoai/segmentation.py,sha256=7yEzBSKCyHW1dNssoK0rdvhxi2IXsIQIFSga817KdI4,11535
 geoai/timm_segment.py,sha256=GfvWmxT6t1S99-iZOf8PlsCkwodIUyrt0AwO_j6dCjE,38470
 geoai/timm_train.py,sha256=y_Sm9Fwe7bTsHEKdtPee5rGY7s01CbkAZKP1TwUDXlU,20551
-geoai/train.py,sha256=Ef-lCCQvaMWl3wvhi-IYYi9sdR4YBqMt9QkfiRAUlkQ,174762
-geoai/utils.py,sha256=AUdVj1tt864UFxJtsatpUmXRV9-Lw4f4tbdyjqj0c3c,360240
+geoai/train.py,sha256=NtT5EDoHEQKFUcAdEy4zVkGsJU8pqzk8H9alfR90BSY,175838
+geoai/utils.py,sha256=2G3PeXTiTTqF6FzG9z3NX8q5PrxMZcUoBkQFKK4BW-k,369320
 geoai/agents/__init__.py,sha256=5xtb_dGpI26nPFcAm8Dj7O4bLskqr1xTw2BRQqbgH4w,285
 geoai/agents/catalog_models.py,sha256=19E-PiE7FvpGEiOi4gDMKPf257FOhLseuVGWJbOjrDs,2089
 geoai/agents/catalog_tools.py,sha256=psVw7-di65hhnJUFqWXFoOkbGaG2_sHrQhA5vdXp3x4,33597
@@ -25,9 +25,9 @@ geoai/agents/stac_tools.py,sha256=ILUg2xFRXVZ9WHOfPeJBvPSFT7lRsPLnGMZhnpDZ1co,16
 geoai/tools/__init__.py,sha256=McC49tQjxrTha1TS69IeM3rRvqVQP3H1NdAZPZPpKEI,1683
 geoai/tools/cloudmask.py,sha256=qzvqVa8FAEgd8mePXBaV5Ptx4fHhwfS1BsYL0JAZBjM,14500
 geoai/tools/multiclean.py,sha256=TVwmWgeQyGIyUuCe10b6pGCtgIl8TkZmcgVXPimn9uM,11949
-geoai_py-0.18.0.dist-info/licenses/LICENSE,sha256=TlBm8mRusRVB9yF2NTg-STcb71v69-XZaKaPdshqP2I,1074
-geoai_py-0.18.0.dist-info/METADATA,sha256=iqGhGU99OgqXBXfMF5r4GfyrByGQFFzx3PHBOAxxYG0,11255
-geoai_py-0.18.0.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-geoai_py-0.18.0.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
-geoai_py-0.18.0.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
-geoai_py-0.18.0.dist-info/RECORD,,
+geoai_py-0.18.2.dist-info/licenses/LICENSE,sha256=TlBm8mRusRVB9yF2NTg-STcb71v69-XZaKaPdshqP2I,1074
+geoai_py-0.18.2.dist-info/METADATA,sha256=FwfNDx3eGYkSzZB5xz2x_-g8SZAy5iu4Wdzl1KcBRGw,11263
+geoai_py-0.18.2.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+geoai_py-0.18.2.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
+geoai_py-0.18.2.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
+geoai_py-0.18.2.dist-info/RECORD,,